Module org.jooq
Package org.jooq.conf

Class Settings

java.lang.Object
org.jooq.conf.Settings
All Implemented Interfaces:
Serializable, Cloneable, XMLAppendable

public class Settings extends Object implements Serializable, Cloneable, XMLAppendable
Settings that influence the way jOOQ renders SQL code.
See Also:
  • Field Details

    • forceIntegerTypesOnZeroScaleDecimals

      protected Boolean forceIntegerTypesOnZeroScaleDecimals
    • renderCatalog

      protected Boolean renderCatalog
    • renderSchema

      protected Boolean renderSchema
    • renderTable

      protected RenderTable renderTable
    • renderMapping

      protected RenderMapping renderMapping
    • renderQuotedNames

      protected RenderQuotedNames renderQuotedNames
    • renderNameCase

      protected RenderNameCase renderNameCase
    • renderNameStyle

      protected RenderNameStyle renderNameStyle
    • renderNamedParamPrefix

      protected String renderNamedParamPrefix
    • renderKeywordCase

      protected RenderKeywordCase renderKeywordCase
    • renderKeywordStyle

      protected RenderKeywordStyle renderKeywordStyle
    • renderLocale

      protected Locale renderLocale
    • renderFormatted

      protected Boolean renderFormatted
    • renderFormatting

      protected RenderFormatting renderFormatting
    • renderOptionalAssociativityParentheses

      protected RenderOptionalKeyword renderOptionalAssociativityParentheses
    • renderOptionalAsKeywordForTableAliases

      protected RenderOptionalKeyword renderOptionalAsKeywordForTableAliases
    • renderOptionalAsKeywordForFieldAliases

      protected RenderOptionalKeyword renderOptionalAsKeywordForFieldAliases
    • renderOptionalInnerKeyword

      protected RenderOptionalKeyword renderOptionalInnerKeyword
    • renderOptionalOuterKeyword

      protected RenderOptionalKeyword renderOptionalOuterKeyword
    • renderImplicitWindowRange

      protected RenderImplicitWindowRange renderImplicitWindowRange
    • renderScalarSubqueriesForStoredFunctions

      protected Boolean renderScalarSubqueriesForStoredFunctions
    • renderImplicitJoinType

      protected RenderImplicitJoinType renderImplicitJoinType
    • renderImplicitJoinToManyType

      protected RenderImplicitJoinType renderImplicitJoinToManyType
    • renderDefaultNullability

      protected RenderDefaultNullability renderDefaultNullability
    • renderCoalesceToEmptyStringInConcat

      protected Boolean renderCoalesceToEmptyStringInConcat
    • renderOrderByRownumberForEmulatedPagination

      protected Boolean renderOrderByRownumberForEmulatedPagination
    • renderOutputForSQLServerReturningClause

      protected Boolean renderOutputForSQLServerReturningClause
    • renderGroupConcatMaxLenSessionVariable

      protected Boolean renderGroupConcatMaxLenSessionVariable
    • renderParenthesisAroundSetOperationQueries

      protected Boolean renderParenthesisAroundSetOperationQueries
    • renderVariablesInDerivedTablesForEmulations

      protected Boolean renderVariablesInDerivedTablesForEmulations
    • renderRowConditionForSeekClause

      protected Boolean renderRowConditionForSeekClause
    • renderRedundantConditionForSeekClause

      protected Boolean renderRedundantConditionForSeekClause
    • renderPlainSQLTemplatesAsRaw

      protected Boolean renderPlainSQLTemplatesAsRaw
    • renderDollarQuotedStringToken

      protected String renderDollarQuotedStringToken
    • namePathSeparator

      protected String namePathSeparator
    • bindOffsetDateTimeType

      protected Boolean bindOffsetDateTimeType
    • bindOffsetTimeType

      protected Boolean bindOffsetTimeType
    • fetchTriggerValuesAfterSQLServerOutput

      protected Boolean fetchTriggerValuesAfterSQLServerOutput
    • fetchTriggerValuesAfterReturning

      protected FetchTriggerValuesAfterReturning fetchTriggerValuesAfterReturning
    • fetchIntermediateResult

      protected FetchIntermediateResult fetchIntermediateResult
    • diagnosticsDuplicateStatements

      protected Boolean diagnosticsDuplicateStatements
    • diagnosticsDuplicateStatementsUsingTransformPatterns

      protected Boolean diagnosticsDuplicateStatementsUsingTransformPatterns
    • diagnosticsMissingWasNullCall

      protected Boolean diagnosticsMissingWasNullCall
    • diagnosticsRepeatedStatements

      protected Boolean diagnosticsRepeatedStatements
    • diagnosticsConsecutiveAggregation

      protected Boolean diagnosticsConsecutiveAggregation
    • diagnosticsConcatenationInPredicate

      protected Boolean diagnosticsConcatenationInPredicate
    • diagnosticsPossiblyWrongExpression

      protected Boolean diagnosticsPossiblyWrongExpression
    • diagnosticsTooManyColumnsFetched

      protected Boolean diagnosticsTooManyColumnsFetched
    • diagnosticsTooManyRowsFetched

      protected Boolean diagnosticsTooManyRowsFetched
    • diagnosticsUnnecessaryWasNullCall

      protected Boolean diagnosticsUnnecessaryWasNullCall
    • diagnosticsPatterns

      protected Boolean diagnosticsPatterns
    • diagnosticsTrivialCondition

      protected Boolean diagnosticsTrivialCondition
    • diagnosticsNullCondition

      protected Boolean diagnosticsNullCondition
    • transformPatterns

      protected Boolean transformPatterns
    • transformPatternsLogging

      protected Boolean transformPatternsLogging
    • transformPatternsUnnecessaryDistinct

      protected Boolean transformPatternsUnnecessaryDistinct
    • transformPatternsUnnecessaryScalarSubquery

      protected Boolean transformPatternsUnnecessaryScalarSubquery
    • transformPatternsUnnecessaryInnerJoin

      protected Boolean transformPatternsUnnecessaryInnerJoin
    • transformPatternsUnnecessaryGroupByExpressions

      protected Boolean transformPatternsUnnecessaryGroupByExpressions
    • transformPatternsUnnecessaryOrderByExpressions

      protected Boolean transformPatternsUnnecessaryOrderByExpressions
    • transformPatternsUnnecessaryExistsSubqueryClauses

      protected Boolean transformPatternsUnnecessaryExistsSubqueryClauses
    • transformPatternsCountConstant

      protected Boolean transformPatternsCountConstant
    • transformPatternsTrim

      protected Boolean transformPatternsTrim
    • transformPatternsNotAnd

      protected Boolean transformPatternsNotAnd
    • transformPatternsNotOr

      protected Boolean transformPatternsNotOr
    • transformPatternsNotNot

      protected Boolean transformPatternsNotNot
    • transformPatternsNotComparison

      protected Boolean transformPatternsNotComparison
    • transformPatternsNotNotDistinct

      protected Boolean transformPatternsNotNotDistinct
    • transformPatternsDistinctFromNull

      protected Boolean transformPatternsDistinctFromNull
    • transformPatternsNormaliseAssociativeOps

      protected Boolean transformPatternsNormaliseAssociativeOps
    • transformPatternsNormaliseInListSingleElementToComparison

      protected Boolean transformPatternsNormaliseInListSingleElementToComparison
    • transformPatternsNormaliseFieldCompareValue

      protected Boolean transformPatternsNormaliseFieldCompareValue
    • transformPatternsNormaliseCoalesceToNvl

      protected Boolean transformPatternsNormaliseCoalesceToNvl
    • transformPatternsOrEqToIn

      protected Boolean transformPatternsOrEqToIn
    • transformPatternsAndNeToNotIn

      protected Boolean transformPatternsAndNeToNotIn
    • transformPatternsMergeOrComparison

      protected Boolean transformPatternsMergeOrComparison
    • transformPatternsMergeAndComparison

      protected Boolean transformPatternsMergeAndComparison
    • transformPatternsMergeInLists

      protected Boolean transformPatternsMergeInLists
    • transformPatternsMergeRangePredicates

      protected Boolean transformPatternsMergeRangePredicates
    • transformPatternsMergeBetweenSymmetricPredicates

      protected Boolean transformPatternsMergeBetweenSymmetricPredicates
    • transformPatternsCaseSearchedToCaseSimple

      protected Boolean transformPatternsCaseSearchedToCaseSimple
    • transformPatternsCaseElseNull

      protected Boolean transformPatternsCaseElseNull
    • transformPatternsUnreachableCaseClauses

      protected Boolean transformPatternsUnreachableCaseClauses
    • transformPatternsUnreachableDecodeClauses

      protected Boolean transformPatternsUnreachableDecodeClauses
    • transformPatternsCaseDistinctToDecode

      protected Boolean transformPatternsCaseDistinctToDecode
    • transformPatternsCaseMergeWhenWhen

      protected Boolean transformPatternsCaseMergeWhenWhen
    • transformPatternsCaseMergeWhenElse

      protected Boolean transformPatternsCaseMergeWhenElse
    • transformPatternsCaseToCaseAbbreviation

      protected Boolean transformPatternsCaseToCaseAbbreviation
    • transformPatternsSimplifyCaseAbbreviation

      protected Boolean transformPatternsSimplifyCaseAbbreviation
    • transformPatternsFlattenCaseAbbreviation

      protected Boolean transformPatternsFlattenCaseAbbreviation
    • transformPatternsFlattenDecode

      protected Boolean transformPatternsFlattenDecode
    • transformPatternsFlattenCase

      protected Boolean transformPatternsFlattenCase
    • transformPatternsTrivialCaseAbbreviation

      protected Boolean transformPatternsTrivialCaseAbbreviation
    • transformPatternsTrivialPredicates

      protected Boolean transformPatternsTrivialPredicates
    • transformPatternsTrivialBitwiseOperations

      protected Boolean transformPatternsTrivialBitwiseOperations
    • transformPatternsBitSet

      protected Boolean transformPatternsBitSet
    • transformPatternsBitGet

      protected Boolean transformPatternsBitGet
    • transformPatternsScalarSubqueryCountAsteriskGtZero

      protected Boolean transformPatternsScalarSubqueryCountAsteriskGtZero
    • transformPatternsScalarSubqueryCountExpressionGtZero

      protected Boolean transformPatternsScalarSubqueryCountExpressionGtZero
    • transformPatternsEmptyScalarSubquery

      protected Boolean transformPatternsEmptyScalarSubquery
    • transformPatternsNegNeg

      protected Boolean transformPatternsNegNeg
    • transformPatternsBitNotBitNot

      protected Boolean transformPatternsBitNotBitNot
    • transformPatternsBitNotBitNand

      protected Boolean transformPatternsBitNotBitNand
    • transformPatternsBitNotBitNor

      protected Boolean transformPatternsBitNotBitNor
    • transformPatternsBitNotBitXNor

      protected Boolean transformPatternsBitNotBitXNor
    • transformPatternsNullOnNullInput

      protected Boolean transformPatternsNullOnNullInput
    • transformPatternsIdempotentFunctionRepetition

      protected Boolean transformPatternsIdempotentFunctionRepetition
    • transformPatternsArithmeticComparisons

      protected Boolean transformPatternsArithmeticComparisons
    • transformPatternsArithmeticExpressions

      protected Boolean transformPatternsArithmeticExpressions
    • transformPatternsTrigonometricFunctions

      protected Boolean transformPatternsTrigonometricFunctions
    • transformPatternsLogarithmicFunctions

      protected Boolean transformPatternsLogarithmicFunctions
    • transformPatternsHyperbolicFunctions

      protected Boolean transformPatternsHyperbolicFunctions
    • transformPatternsInverseHyperbolicFunctions

      protected Boolean transformPatternsInverseHyperbolicFunctions
    • transformInlineBindValuesForFieldComparisons

      protected Boolean transformInlineBindValuesForFieldComparisons
    • transformAnsiJoinToTableLists

      protected Boolean transformAnsiJoinToTableLists
    • transformInConditionSubqueryWithLimitToDerivedTable

      protected Transformation transformInConditionSubqueryWithLimitToDerivedTable
    • transformQualify

      protected Transformation transformQualify
    • transformTableListsToAnsiJoin

      protected Boolean transformTableListsToAnsiJoin
    • transformRownum

      protected Transformation transformRownum
    • transformUnneededArithmeticExpressions

      protected TransformUnneededArithmeticExpressions transformUnneededArithmeticExpressions
    • transformGroupByColumnIndex

      protected Transformation transformGroupByColumnIndex
    • transformInlineCTE

      protected Transformation transformInlineCTE
    • backslashEscaping

      protected BackslashEscaping backslashEscaping
    • paramType

      protected ParamType paramType
    • paramCastMode

      protected ParamCastMode paramCastMode
    • statementType

      protected StatementType statementType
    • inlineThreshold

      protected Integer inlineThreshold
    • transactionListenerStartInvocationOrder

      protected InvocationOrder transactionListenerStartInvocationOrder
    • transactionListenerEndInvocationOrder

      protected InvocationOrder transactionListenerEndInvocationOrder
    • migrationListenerStartInvocationOrder

      protected InvocationOrder migrationListenerStartInvocationOrder
    • migrationListenerEndInvocationOrder

      protected InvocationOrder migrationListenerEndInvocationOrder
    • visitListenerStartInvocationOrder

      protected InvocationOrder visitListenerStartInvocationOrder
    • visitListenerEndInvocationOrder

      protected InvocationOrder visitListenerEndInvocationOrder
    • recordListenerStartInvocationOrder

      protected InvocationOrder recordListenerStartInvocationOrder
    • recordListenerEndInvocationOrder

      protected InvocationOrder recordListenerEndInvocationOrder
    • executeListenerStartInvocationOrder

      protected InvocationOrder executeListenerStartInvocationOrder
    • executeListenerEndInvocationOrder

      protected InvocationOrder executeListenerEndInvocationOrder
    • executeLogging

      protected Boolean executeLogging
    • executeLoggingSQLExceptions

      protected Boolean executeLoggingSQLExceptions
    • diagnosticsLogging

      protected Boolean diagnosticsLogging
    • diagnosticsConnection

      protected DiagnosticsConnection diagnosticsConnection
    • updateRecordVersion

      protected Boolean updateRecordVersion
    • updateRecordTimestamp

      protected Boolean updateRecordTimestamp
    • executeWithOptimisticLocking

      protected Boolean executeWithOptimisticLocking
    • executeWithOptimisticLockingExcludeUnversioned

      protected Boolean executeWithOptimisticLockingExcludeUnversioned
    • attachRecords

      protected Boolean attachRecords
    • insertUnchangedRecords

      protected Boolean insertUnchangedRecords
    • updateUnchangedRecords

      protected UpdateUnchangedRecords updateUnchangedRecords
    • updatablePrimaryKeys

      protected Boolean updatablePrimaryKeys
    • reflectionCaching

      protected Boolean reflectionCaching
    • cacheRecordMappers

      protected Boolean cacheRecordMappers
    • cacheParsingConnection

      protected Boolean cacheParsingConnection
    • cacheParsingConnectionLRUCacheSize

      protected Integer cacheParsingConnectionLRUCacheSize
    • cachePreparedStatementInLoader

      protected Boolean cachePreparedStatementInLoader
    • throwExceptions

      protected ThrowExceptions throwExceptions
    • fetchWarnings

      protected Boolean fetchWarnings
    • fetchServerOutputSize

      protected Integer fetchServerOutputSize
    • returnIdentityOnUpdatableRecord

      protected Boolean returnIdentityOnUpdatableRecord
    • returnDefaultOnUpdatableRecord

      protected Boolean returnDefaultOnUpdatableRecord
    • returnComputedOnUpdatableRecord

      protected Boolean returnComputedOnUpdatableRecord
    • returnAllOnUpdatableRecord

      protected Boolean returnAllOnUpdatableRecord
    • returnRecordToPojo

      protected Boolean returnRecordToPojo
    • mapJPAAnnotations

      protected Boolean mapJPAAnnotations
    • mapRecordComponentParameterNames

      protected Boolean mapRecordComponentParameterNames
    • mapConstructorPropertiesParameterNames

      protected Boolean mapConstructorPropertiesParameterNames
    • mapConstructorParameterNames

      protected Boolean mapConstructorParameterNames
    • mapConstructorParameterNamesInKotlin

      protected Boolean mapConstructorParameterNamesInKotlin
    • queryPoolable

      protected QueryPoolable queryPoolable
    • queryTimeout

      protected Integer queryTimeout
    • maxRows

      protected Integer maxRows
    • fetchSize

      protected Integer fetchSize
    • batchSize

      protected Integer batchSize
    • debugInfoOnStackTrace

      protected Boolean debugInfoOnStackTrace
    • inListPadding

      protected Boolean inListPadding
    • inListPadBase

      protected Integer inListPadBase
    • delimiter

      protected String delimiter
    • emulateOnDuplicateKeyUpdateOnPrimaryKeyOnly

      protected Boolean emulateOnDuplicateKeyUpdateOnPrimaryKeyOnly
    • emulateMultiset

      protected NestedCollectionEmulation emulateMultiset
    • emulateComputedColumns

      protected Boolean emulateComputedColumns
    • executeUpdateWithoutWhere

      protected ExecuteWithoutWhere executeUpdateWithoutWhere
    • executeDeleteWithoutWhere

      protected ExecuteWithoutWhere executeDeleteWithoutWhere
    • interpreterDialect

      protected SQLDialect interpreterDialect
    • interpreterNameLookupCaseSensitivity

      protected InterpreterNameLookupCaseSensitivity interpreterNameLookupCaseSensitivity
    • interpreterLocale

      protected Locale interpreterLocale
    • interpreterDelayForeignKeyDeclarations

      protected Boolean interpreterDelayForeignKeyDeclarations
    • metaIncludeSystemIndexes

      protected Boolean metaIncludeSystemIndexes
    • metaIncludeSystemSequences

      protected Boolean metaIncludeSystemSequences
    • migrationHistorySchema

      protected MigrationSchema migrationHistorySchema
    • migrationHistorySchemaCreateSchemaIfNotExists

      protected Boolean migrationHistorySchemaCreateSchemaIfNotExists
    • migrationDefaultSchema

      protected MigrationSchema migrationDefaultSchema
    • migrationSchemataCreateSchemaIfNotExists

      protected Boolean migrationSchemataCreateSchemaIfNotExists
    • migrationAllowsUndo

      protected Boolean migrationAllowsUndo
    • migrationRevertUntracked

      protected Boolean migrationRevertUntracked
    • migrationAutoBaseline

      protected Boolean migrationAutoBaseline
    • migrationAutoVerification

      protected Boolean migrationAutoVerification
    • migrationIgnoreDefaultTimestampPrecisionDiffs

      protected Boolean migrationIgnoreDefaultTimestampPrecisionDiffs
    • locale

      protected Locale locale
    • parseDialect

      protected SQLDialect parseDialect
    • parseLocale

      protected Locale parseLocale
    • parseDateFormat

      protected String parseDateFormat
    • parseTimestampFormat

      protected String parseTimestampFormat
    • parseNamedParamPrefix

      protected String parseNamedParamPrefix
    • parseNameCase

      protected ParseNameCase parseNameCase
    • parseWithMetaLookups

      protected ParseWithMetaLookups parseWithMetaLookups
    • parseAppendMissingTableReferences

      protected Transformation parseAppendMissingTableReferences
    • parseSetCommands

      protected Boolean parseSetCommands
    • parseUnsupportedSyntax

      protected ParseUnsupportedSyntax parseUnsupportedSyntax
    • parseUnknownFunctions

      protected ParseUnknownFunctions parseUnknownFunctions
    • parseIgnoreCommercialOnlyFeatures

      protected Boolean parseIgnoreCommercialOnlyFeatures
    • parseIgnoreComments

      protected Boolean parseIgnoreComments
    • parseIgnoreCommentStart

      protected String parseIgnoreCommentStart
    • parseIgnoreCommentStop

      protected String parseIgnoreCommentStop
    • parseRetainCommentsBetweenQueries

      protected Boolean parseRetainCommentsBetweenQueries
    • parseMetaDefaultExpressions

      protected Boolean parseMetaDefaultExpressions
    • parseMetaViewSources

      protected Boolean parseMetaViewSources
    • readonlyTableRecordInsert

      protected WriteIfReadonly readonlyTableRecordInsert
    • readonlyUpdatableRecordUpdate

      protected WriteIfReadonly readonlyUpdatableRecordUpdate
    • readonlyInsert

      protected WriteIfReadonly readonlyInsert
    • readonlyUpdate

      protected WriteIfReadonly readonlyUpdate
    • applyWorkaroundFor7962

      protected Boolean applyWorkaroundFor7962
    • warnOnStaticTypeRegistryAccess

      protected Warning warnOnStaticTypeRegistryAccess
    • interpreterSearchPath

      protected List<InterpreterSearchSchema> interpreterSearchPath
    • migrationSchemata

      protected List<MigrationSchema> migrationSchemata
    • parseSearchPath

      protected List<ParseSearchSchema> parseSearchPath
  • Constructor Details

    • Settings

      public Settings()
  • Method Details

    • isForceIntegerTypesOnZeroScaleDecimals

      public Boolean isForceIntegerTypesOnZeroScaleDecimals()
      Historically, zero-scale decimal types are generated as their most appropriate, corresponding integer type (e.g. NUMBER(2, 0) and less: Byte). The same behaviour is replicated in the Meta API. This flag allows for turning off this feature.
      Returns:
      possible object is Boolean
    • setForceIntegerTypesOnZeroScaleDecimals

      public void setForceIntegerTypesOnZeroScaleDecimals(Boolean value)
      Historically, zero-scale decimal types are generated as their most appropriate, corresponding integer type (e.g. NUMBER(2, 0) and less: Byte). The same behaviour is replicated in the Meta API. This flag allows for turning off this feature.
      Parameters:
      value - allowed object is Boolean
    • isRenderCatalog

      public Boolean isRenderCatalog()
      Whether any catalog name should be rendered at all.

      Use this for single-catalog environments, or when all objects are made available using synonyms

      Returns:
      possible object is Boolean
    • setRenderCatalog

      public void setRenderCatalog(Boolean value)
      Whether any catalog name should be rendered at all.

      Use this for single-catalog environments, or when all objects are made available using synonyms

      Parameters:
      value - allowed object is Boolean
    • isRenderSchema

      public Boolean isRenderSchema()
      Whether any schema name should be rendered at all.

      Setting this to false also implicitly sets "renderCatalog" to false.

      Use this for single-schema environments, or when all objects are made available using synonyms

      Returns:
      possible object is Boolean
    • setRenderSchema

      public void setRenderSchema(Boolean value)
      Whether any schema name should be rendered at all.

      Setting this to false also implicitly sets "renderCatalog" to false.

      Use this for single-schema environments, or when all objects are made available using synonyms

      Parameters:
      value - allowed object is Boolean
    • getRenderTable

      public RenderTable getRenderTable()
      Whether any table name qualification should be rendered at all on columns.

      Setting when tables aren't rendered, then implicitly, schemas and catalogs aren't rendered either.

      The following values are available:

      • RenderTable.ALWAYS: The default, which should always be preferred. Columns are always qualified with their tables, where possible.
      • RenderTable.WHEN_MULTIPLE_TABLES: The simplest option to reduce generated query verbosity, avoiding table qualification only in queries with a single table in the FROM clause.
      • RenderTable.WHEN_AMBIGUOUS_COLUMNS: A much more expensive to compute option that checks the FROM clause for ambiguous column names, in case of which columns are qualified.
      • RenderTable.NEVER: Always turn off table qualification.

      Use this when verbosity of rendered SQL is a problem.

    • setRenderTable

      public void setRenderTable(RenderTable value)
      Whether any table name qualification should be rendered at all on columns.

      Setting when tables aren't rendered, then implicitly, schemas and catalogs aren't rendered either.

      The following values are available:

      • RenderTable.ALWAYS: The default, which should always be preferred. Columns are always qualified with their tables, where possible.
      • RenderTable.WHEN_MULTIPLE_TABLES: The simplest option to reduce generated query verbosity, avoiding table qualification only in queries with a single table in the FROM clause.
      • RenderTable.WHEN_AMBIGUOUS_COLUMNS: A much more expensive to compute option that checks the FROM clause for ambiguous column names, in case of which columns are qualified.
      • RenderTable.NEVER: Always turn off table qualification.

      Use this when verbosity of rendered SQL is a problem.

    • getRenderMapping

      public RenderMapping getRenderMapping()
      Configure render mapping for runtime schema / table rewriting in generated SQL.
    • setRenderMapping

      public void setRenderMapping(RenderMapping value)
      Configure render mapping for runtime schema / table rewriting in generated SQL.
    • getRenderQuotedNames

      public RenderQuotedNames getRenderQuotedNames()
      Whether rendered schema, table, column names, etc should be quoted.

      This only affects names created through DSL.name(String) methods (including those that are implicitly created through this method), not DSL.quotedName(String) or DSL.unquotedName(String), whose behaviour cannot be overridden.

      This setting does not affect any plain SQL usage.

    • setRenderQuotedNames

      public void setRenderQuotedNames(RenderQuotedNames value)
      Whether rendered schema, table, column names, etc should be quoted.

      This only affects names created through DSL.name(String) methods (including those that are implicitly created through this method), not DSL.quotedName(String) or DSL.unquotedName(String), whose behaviour cannot be overridden.

      This setting does not affect any plain SQL usage.

    • getRenderNameCase

      public RenderNameCase getRenderNameCase()
      Whether the case of Name references should be modified in any way.

      Names are modified irrespective of the getRenderQuotedNames() setting.

      This setting does not affect any plain SQL usage.

    • setRenderNameCase

      public void setRenderNameCase(RenderNameCase value)
      Whether the case of Name references should be modified in any way.

      Names are modified irrespective of the getRenderQuotedNames() setting.

      This setting does not affect any plain SQL usage.

    • getRenderNameStyle

      @Deprecated public RenderNameStyle getRenderNameStyle()
      Deprecated.
      - 3.12.0 - [#5909] - Use RenderQuotedNames and RenderNameCase instead.
      Whether rendered schema, table, column names, etc should be quoted in rendered SQL, or transformed in any other way.

      This is set to "QUOTED" by default for backwards-compatibility.

    • setRenderNameStyle

      @Deprecated public void setRenderNameStyle(RenderNameStyle value)
      Deprecated.
      - 3.12.0 - [#5909] - Use RenderQuotedNames and RenderNameCase instead.
      Whether rendered schema, table, column names, etc should be quoted in rendered SQL, or transformed in any other way.

      This is set to "QUOTED" by default for backwards-compatibility.

    • getRenderNamedParamPrefix

      public String getRenderNamedParamPrefix()
      The prefix to use for named parameters in generated SQL.

      Named parameter syntax defaults to :name (such as supported by Oracle, JPA, Spring), but vendor specific parameters may look differently. This flag can be used to determine the prefix to be used by named parameters, such as @ for SQL Server's @name or $ for PostgreSQL's $name, when generating SQL.

      "Named indexed" parameters can be obtained in the same way by specifingy ParamType#NAMED and not providing a name to parameters, resulting in :1 or @1 or $1, etc.

    • setRenderNamedParamPrefix

      public void setRenderNamedParamPrefix(String value)
      The prefix to use for named parameters in generated SQL.

      Named parameter syntax defaults to :name (such as supported by Oracle, JPA, Spring), but vendor specific parameters may look differently. This flag can be used to determine the prefix to be used by named parameters, such as @ for SQL Server's @name or $ for PostgreSQL's $name, when generating SQL.

      "Named indexed" parameters can be obtained in the same way by specifingy ParamType#NAMED and not providing a name to parameters, resulting in :1 or @1 or $1, etc.

    • getRenderKeywordCase

      public RenderKeywordCase getRenderKeywordCase()
      Whether the case of Keyword references should be modified in any way.
    • setRenderKeywordCase

      public void setRenderKeywordCase(RenderKeywordCase value)
      Whether the case of Keyword references should be modified in any way.
    • getRenderKeywordStyle

      @Deprecated public RenderKeywordStyle getRenderKeywordStyle()
      Deprecated.
      - 3.12.0 - [#5909] - Use RenderKeywordCase instead.
      Whether the case of Keyword references should be modified in any way.

    • setRenderKeywordStyle

      @Deprecated public void setRenderKeywordStyle(RenderKeywordStyle value)
      Deprecated.
      - 3.12.0 - [#5909] - Use RenderKeywordCase instead.
      Whether the case of Keyword references should be modified in any way.

    • getRenderLocale

      public Locale getRenderLocale()
      The Locale to be used with any render locale dependent logic (as e.g. transforming names to lower / uppper case), defaulting to getLocale().
    • setRenderLocale

      public void setRenderLocale(Locale value)
      The Locale to be used with any render locale dependent logic (as e.g. transforming names to lower / uppper case), defaulting to getLocale().
    • isRenderFormatted

      public Boolean isRenderFormatted()
      Whether rendered SQL should be pretty-printed.
      Returns:
      possible object is Boolean
    • setRenderFormatted

      public void setRenderFormatted(Boolean value)
      Whether rendered SQL should be pretty-printed.
      Parameters:
      value - allowed object is Boolean
    • getRenderFormatting

      public RenderFormatting getRenderFormatting()
      All sorts of formatting flags / settings.
    • setRenderFormatting

      public void setRenderFormatting(RenderFormatting value)
      All sorts of formatting flags / settings.
    • getRenderOptionalAssociativityParentheses

      public RenderOptionalKeyword getRenderOptionalAssociativityParentheses()
      Whether to render optional parentheses to make associativity explicit, e.g. ((a + b) + c) instead of (a + b + c).
    • setRenderOptionalAssociativityParentheses

      public void setRenderOptionalAssociativityParentheses(RenderOptionalKeyword value)
      Whether to render optional parentheses to make associativity explicit, e.g. ((a + b) + c) instead of (a + b + c).
    • getRenderOptionalAsKeywordForTableAliases

      public RenderOptionalKeyword getRenderOptionalAsKeywordForTableAliases()
      Whether to render the optional AS keyword in table aliases, if it is optional in the output dialect. This is ignored if the keyword is not supported (e.g. in Oracle)
    • setRenderOptionalAsKeywordForTableAliases

      public void setRenderOptionalAsKeywordForTableAliases(RenderOptionalKeyword value)
      Whether to render the optional AS keyword in table aliases, if it is optional in the output dialect. This is ignored if the keyword is not supported (e.g. in Oracle)
    • getRenderOptionalAsKeywordForFieldAliases

      public RenderOptionalKeyword getRenderOptionalAsKeywordForFieldAliases()
      Whether to render the optional AS keyword in table aliases, if it is optional in the output dialect.
    • setRenderOptionalAsKeywordForFieldAliases

      public void setRenderOptionalAsKeywordForFieldAliases(RenderOptionalKeyword value)
      Whether to render the optional AS keyword in table aliases, if it is optional in the output dialect.
    • getRenderOptionalInnerKeyword

      public RenderOptionalKeyword getRenderOptionalInnerKeyword()
      Whether to render the optional INNER keyword in INNER JOIN, if it is optional in the output dialect.
    • setRenderOptionalInnerKeyword

      public void setRenderOptionalInnerKeyword(RenderOptionalKeyword value)
      Whether to render the optional INNER keyword in INNER JOIN, if it is optional in the output dialect.
    • getRenderOptionalOuterKeyword

      public RenderOptionalKeyword getRenderOptionalOuterKeyword()
      Whether to render the optional OUTER keyword in OUTER JOIN, if it is optional in the output dialect.
    • setRenderOptionalOuterKeyword

      public void setRenderOptionalOuterKeyword(RenderOptionalKeyword value)
      Whether to render the optional OUTER keyword in OUTER JOIN, if it is optional in the output dialect.
    • getRenderImplicitWindowRange

      public RenderImplicitWindowRange getRenderImplicitWindowRange()
      Whether to render an explicit window RANGE clause when an implicit clause is applied.
    • setRenderImplicitWindowRange

      public void setRenderImplicitWindowRange(RenderImplicitWindowRange value)
      Whether to render an explicit window RANGE clause when an implicit clause is applied.
    • isRenderScalarSubqueriesForStoredFunctions

      public Boolean isRenderScalarSubqueriesForStoredFunctions()
      Whether stored function calls should be wrapped in scalar subqueries.

      Oracle 11g (and potentially, other databases too) implements scalar subquery caching. With this flag set to true, users can automatically profit from this feature in all SQL statements.

      Returns:
      possible object is Boolean
    • setRenderScalarSubqueriesForStoredFunctions

      public void setRenderScalarSubqueriesForStoredFunctions(Boolean value)
      Whether stored function calls should be wrapped in scalar subqueries.

      Oracle 11g (and potentially, other databases too) implements scalar subquery caching. With this flag set to true, users can automatically profit from this feature in all SQL statements.

      Parameters:
      value - allowed object is Boolean
    • getRenderImplicitJoinType

      public RenderImplicitJoinType getRenderImplicitJoinType()
      The join type to be generated by implicit joins for to-one paths in Select queries.

      The DEFAULT is dependent on the nullability of the foreign key (LEFT_JOIN for nullable foreign keys and INNER_JOIN for non-nullable foreign keys). In DML statements, it is always SCALAR_SUBQUERY, unless DML joins are supported.

    • setRenderImplicitJoinType

      public void setRenderImplicitJoinType(RenderImplicitJoinType value)
      The join type to be generated by implicit joins for to-one paths in Select queries.

      The DEFAULT is dependent on the nullability of the foreign key (LEFT_JOIN for nullable foreign keys and INNER_JOIN for non-nullable foreign keys). In DML statements, it is always SCALAR_SUBQUERY, unless DML joins are supported.

    • getRenderImplicitJoinToManyType

      public RenderImplicitJoinType getRenderImplicitJoinToManyType()
      The join type to be generated by implicit joins for to-many paths in Select queries.

      The DEFAULT is SCALAR_SUBQUERY if the join path is implicit only, i.e. absent from the FROM clause, to prevent accidental cartesian products, or LEFT_JOIN if declared explicitly in the FROM clause. In DML statements, it is always SCALAR_SUBQUERY, unless DML joins are supported.

    • setRenderImplicitJoinToManyType

      public void setRenderImplicitJoinToManyType(RenderImplicitJoinType value)
      The join type to be generated by implicit joins for to-many paths in Select queries.

      The DEFAULT is SCALAR_SUBQUERY if the join path is implicit only, i.e. absent from the FROM clause, to prevent accidental cartesian products, or LEFT_JOIN if declared explicitly in the FROM clause. In DML statements, it is always SCALAR_SUBQUERY, unless DML joins are supported.

    • getRenderDefaultNullability

      public RenderDefaultNullability getRenderDefaultNullability()
      Whether the Nullability.DEFAULT nullablity should be rendered in generated DDL, and how it should be rendered.
    • setRenderDefaultNullability

      public void setRenderDefaultNullability(RenderDefaultNullability value)
      Whether the Nullability.DEFAULT nullablity should be rendered in generated DDL, and how it should be rendered.
    • isRenderCoalesceToEmptyStringInConcat

      public Boolean isRenderCoalesceToEmptyStringInConcat()
      Whether stored function calls should be wrapped in scalar subqueries.

      Oracle 11g (and potentially, other databases too) implements scalar subquery caching. With this flag set to true, users can automatically profit from this feature in all SQL statements.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setRenderCoalesceToEmptyStringInConcat

      public void setRenderCoalesceToEmptyStringInConcat(Boolean value)
      Whether stored function calls should be wrapped in scalar subqueries.

      Oracle 11g (and potentially, other databases too) implements scalar subquery caching. With this flag set to true, users can automatically profit from this feature in all SQL statements.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isRenderOrderByRownumberForEmulatedPagination

      public Boolean isRenderOrderByRownumberForEmulatedPagination()
      Whether an additional ORDER BY rn clause should be rendered on emulated paginated queries.

      Older databases did not support OFFSET .. FETCH pagination, so jOOQ emulates it using derived tables and ROWNUM (Oracle 11g and older) or ROW_NUMBER() (e.g. DB2, SQL Server, etc.) filtering. While these subqueries are ordered, the ordering is not guaranteed to be stable in the outer most queries. It may be stable (and e.g. in Oracle, it mostly is, if queries are not parallel, or joined to other queries, etc.), so the excess ORDER BY clause may add some additional performance overhead. This setting forces jOOQ to not generate the additional ORDER BY clause.

      For details, see https://github.com/jOOQ/jOOQ/issues/7609.

      Returns:
      possible object is Boolean
    • setRenderOrderByRownumberForEmulatedPagination

      public void setRenderOrderByRownumberForEmulatedPagination(Boolean value)
      Whether an additional ORDER BY rn clause should be rendered on emulated paginated queries.

      Older databases did not support OFFSET .. FETCH pagination, so jOOQ emulates it using derived tables and ROWNUM (Oracle 11g and older) or ROW_NUMBER() (e.g. DB2, SQL Server, etc.) filtering. While these subqueries are ordered, the ordering is not guaranteed to be stable in the outer most queries. It may be stable (and e.g. in Oracle, it mostly is, if queries are not parallel, or joined to other queries, etc.), so the excess ORDER BY clause may add some additional performance overhead. This setting forces jOOQ to not generate the additional ORDER BY clause.

      For details, see https://github.com/jOOQ/jOOQ/issues/7609.

      Parameters:
      value - allowed object is Boolean
    • isRenderOutputForSQLServerReturningClause

      public Boolean isRenderOutputForSQLServerReturningClause()
      Whether the jOOQ RETURNING clause should map to SQL Server's OUTPUT clause.

      SQL Server supports an OUTPUT clause in most DML statements, whose behaviour is almost identical to RETURNING in Firebird, Oracle, PostgreSQL. Users who want to prevent jOOQ from rendering this OUTPUT clause can deactivate this flag to revert to jOOQ calling java.sql.Statement#getGeneratedKeys() instead, which is only supported for single row inserts.

      This OUTPUT clause does not support fetching trigger generated values. In order to fetch trigger generated values, fetchTriggerValuesAfterReturning needs to be enabled as well.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

      Returns:
      possible object is Boolean
    • setRenderOutputForSQLServerReturningClause

      public void setRenderOutputForSQLServerReturningClause(Boolean value)
      Whether the jOOQ RETURNING clause should map to SQL Server's OUTPUT clause.

      SQL Server supports an OUTPUT clause in most DML statements, whose behaviour is almost identical to RETURNING in Firebird, Oracle, PostgreSQL. Users who want to prevent jOOQ from rendering this OUTPUT clause can deactivate this flag to revert to jOOQ calling java.sql.Statement#getGeneratedKeys() instead, which is only supported for single row inserts.

      This OUTPUT clause does not support fetching trigger generated values. In order to fetch trigger generated values, fetchTriggerValuesAfterReturning needs to be enabled as well.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

      Parameters:
      value - allowed object is Boolean
    • isRenderGroupConcatMaxLenSessionVariable

      public Boolean isRenderGroupConcatMaxLenSessionVariable()
      Whether the jOOQ GROUP_CONCAT function should be overflow-protected by setting the @@group_concat_max_len session variable in MySQL style database systems.

      MySQL truncates GROUP_CONCAT results after a certain length, which may be way too small for jOOQ's usage, especially when using the MULTISET emulation. By default, jOOQ sets a session variable to the highest possible value prior to executing a query containing GROUP_CONCAT. This flag can be used to opt out of this.

      For details, see https://github.com/jOOQ/jOOQ/issues/12092.

      Returns:
      possible object is Boolean
    • setRenderGroupConcatMaxLenSessionVariable

      public void setRenderGroupConcatMaxLenSessionVariable(Boolean value)
      Whether the jOOQ GROUP_CONCAT function should be overflow-protected by setting the @@group_concat_max_len session variable in MySQL style database systems.

      MySQL truncates GROUP_CONCAT results after a certain length, which may be way too small for jOOQ's usage, especially when using the MULTISET emulation. By default, jOOQ sets a session variable to the highest possible value prior to executing a query containing GROUP_CONCAT. This flag can be used to opt out of this.

      For details, see https://github.com/jOOQ/jOOQ/issues/12092.

      Parameters:
      value - allowed object is Boolean
    • isRenderParenthesisAroundSetOperationQueries

      public Boolean isRenderParenthesisAroundSetOperationQueries()
      Whether queries combined with set operators (e.g. UNION and UNION ALL) should always be surrounded by a parenthesis pair.

      By default (i.e. when this setting is set to false jOOQ will only render parenthesis pairs around queries combined with set operators when required. This is for example the case when set operators are nested, when non-associative operators like EXCEPT are used, or when the queries are rendered as derived tables.

      When this setting is set to true the queries combined with set operators will always be surrounded by a parenthesis pair.

      For details, see https://github.com/jOOQ/jOOQ/issues/3676 and https://github.com/jOOQ/jOOQ/issues/9751.

      Returns:
      possible object is Boolean
    • setRenderParenthesisAroundSetOperationQueries

      public void setRenderParenthesisAroundSetOperationQueries(Boolean value)
      Whether queries combined with set operators (e.g. UNION and UNION ALL) should always be surrounded by a parenthesis pair.

      By default (i.e. when this setting is set to false jOOQ will only render parenthesis pairs around queries combined with set operators when required. This is for example the case when set operators are nested, when non-associative operators like EXCEPT are used, or when the queries are rendered as derived tables.

      When this setting is set to true the queries combined with set operators will always be surrounded by a parenthesis pair.

      For details, see https://github.com/jOOQ/jOOQ/issues/3676 and https://github.com/jOOQ/jOOQ/issues/9751.

      Parameters:
      value - allowed object is Boolean
    • isRenderVariablesInDerivedTablesForEmulations

      public Boolean isRenderVariablesInDerivedTablesForEmulations()
      Whether emulations that require repeating expressions should render variables for those expressions in derived tables.

      For details, see https://github.com/jOOQ/jOOQ/issues/14065.

      Returns:
      possible object is Boolean
    • setRenderVariablesInDerivedTablesForEmulations

      public void setRenderVariablesInDerivedTablesForEmulations(Boolean value)
      Whether emulations that require repeating expressions should render variables for those expressions in derived tables.

      For details, see https://github.com/jOOQ/jOOQ/issues/14065.

      Parameters:
      value - allowed object is Boolean
    • isRenderRowConditionForSeekClause

      public Boolean isRenderRowConditionForSeekClause()
      Whether a (a, b) invalid input: '<' (:a, :b) row predicate should be rendered for the SEEK clause.

      Some RDBMS may support (a, b) invalid input: '<' (:a, :b) row predicate syntax, which is very convenient for SEEK clause implementations, but fail to optimise this predicate as could be expected. This flag allows for expanding the predicate to the much more verbose, but equivalent (a invalid input: '<' :a) OR (a = :a AND b invalid input: '<' :b). Dialects without native support for row predicates aren't affected by this flag.

      Returns:
      possible object is Boolean
    • setRenderRowConditionForSeekClause

      public void setRenderRowConditionForSeekClause(Boolean value)
      Whether a (a, b) invalid input: '<' (:a, :b) row predicate should be rendered for the SEEK clause.

      Some RDBMS may support (a, b) invalid input: '<' (:a, :b) row predicate syntax, which is very convenient for SEEK clause implementations, but fail to optimise this predicate as could be expected. This flag allows for expanding the predicate to the much more verbose, but equivalent (a invalid input: '<' :a) OR (a = :a AND b invalid input: '<' :b). Dialects without native support for row predicates aren't affected by this flag.

      Parameters:
      value - allowed object is Boolean
    • isRenderRedundantConditionForSeekClause

      public Boolean isRenderRedundantConditionForSeekClause()
      Whether a redundant (a invalid input: '<'= :a) predicate should be rendered for a (a, b) invalid input: '<' (:a, :b) predicate for the SEEK clause.

      Some RDBMS may not be able to properly optimise (a, b) invalid input: '<' ('a', 'b') or (a invalid input: '<' 'a') OR (a = 'a' AND b invalid input: '<' 'b'), and choose an appropriate index. By adding an additional redundant predicate, jOOQ may help the optimiser, e.g. (a invalid input: '<'= :a) AND (a, b) invalid input: '<' ('a', 'b') or (a invalid input: '<'= :a) AND ((a invalid input: '<' 'a') OR (a = 'a' AND b invalid input: '<' 'b'))

      Returns:
      possible object is Boolean
    • setRenderRedundantConditionForSeekClause

      public void setRenderRedundantConditionForSeekClause(Boolean value)
      Whether a redundant (a invalid input: '<'= :a) predicate should be rendered for a (a, b) invalid input: '<' (:a, :b) predicate for the SEEK clause.

      Some RDBMS may not be able to properly optimise (a, b) invalid input: '<' ('a', 'b') or (a invalid input: '<' 'a') OR (a = 'a' AND b invalid input: '<' 'b'), and choose an appropriate index. By adding an additional redundant predicate, jOOQ may help the optimiser, e.g. (a invalid input: '<'= :a) AND (a, b) invalid input: '<' ('a', 'b') or (a invalid input: '<'= :a) AND ((a invalid input: '<' 'a') OR (a = 'a' AND b invalid input: '<' 'b'))

      Parameters:
      value - allowed object is Boolean
    • isRenderPlainSQLTemplatesAsRaw

      public Boolean isRenderPlainSQLTemplatesAsRaw()
      Whether plain SQL templates (SQL) are rendered as raw string content.
      Returns:
      possible object is Boolean
    • setRenderPlainSQLTemplatesAsRaw

      public void setRenderPlainSQLTemplatesAsRaw(Boolean value)
      Whether plain SQL templates (SQL) are rendered as raw string content.
      Parameters:
      value - allowed object is Boolean
    • getRenderDollarQuotedStringToken

      public String getRenderDollarQuotedStringToken()
      The token to place between the $$ signs of a PostgreSQL dollar quoted string generated by jOOQ.
    • setRenderDollarQuotedStringToken

      public void setRenderDollarQuotedStringToken(String value)
      The token to place between the $$ signs of a PostgreSQL dollar quoted string generated by jOOQ.
    • getNamePathSeparator

      public String getNamePathSeparator()
      The character(s) to be used as a separator in paths encoded in a
      invalid @link
      Name

      A few hierarchical mapping features work with paths encoded in names (specifically field aliases), such as the reflective mapping of nested values when aliasing fields as:

      
       SELECT 
         a.first_name AS "book.author.firstName"
         a.last_name AS "book.author.lastName"
       FROM ...
       

      Not all dialects support "." in identifiers. This setting allows for specifying an alternative String to use as separator, e.g. "__".

    • setNamePathSeparator

      public void setNamePathSeparator(String value)
      The character(s) to be used as a separator in paths encoded in a
      invalid @link
      Name

      A few hierarchical mapping features work with paths encoded in names (specifically field aliases), such as the reflective mapping of nested values when aliasing fields as:

      
       SELECT 
         a.first_name AS "book.author.firstName"
         a.last_name AS "book.author.lastName"
       FROM ...
       

      Not all dialects support "." in identifiers. This setting allows for specifying an alternative String to use as separator, e.g. "__".

    • isBindOffsetDateTimeType

      public Boolean isBindOffsetDateTimeType()
      Whether the java.time (JSR 310) type OffsetDateTime should be bound natively to JDBC.

      Historically, jOOQ encoded the java.time types as strings to offer better compatibility with older JDBC drivers. By now, most drivers should support the java.time types. Using them may produce better performance both on the server and on the client side.

      This flag allows for reverting to pre-jOOQ 3.14 behaviour, where the default is to bind these types natively.

      For details, see https://github.com/jOOQ/jOOQ/issues/9902.

      Returns:
      possible object is Boolean
    • setBindOffsetDateTimeType

      public void setBindOffsetDateTimeType(Boolean value)
      Whether the java.time (JSR 310) type OffsetDateTime should be bound natively to JDBC.

      Historically, jOOQ encoded the java.time types as strings to offer better compatibility with older JDBC drivers. By now, most drivers should support the java.time types. Using them may produce better performance both on the server and on the client side.

      This flag allows for reverting to pre-jOOQ 3.14 behaviour, where the default is to bind these types natively.

      For details, see https://github.com/jOOQ/jOOQ/issues/9902.

      Parameters:
      value - allowed object is Boolean
    • isBindOffsetTimeType

      public Boolean isBindOffsetTimeType()
      Whether the java.time (JSR 310) type OffsetTime should be bound natively to JDBC.

      Historically, jOOQ encoded the java.time types as strings to offer better compatibility with older JDBC drivers. By now, most drivers should support the java.time types. Using them may produce better performance both on the server and on the client side.

      This flag allows for reverting to pre-jOOQ 3.14 behaviour, where the default is to bind these types natively.

      For details, see https://github.com/jOOQ/jOOQ/issues/9902.

      Returns:
      possible object is Boolean
    • setBindOffsetTimeType

      public void setBindOffsetTimeType(Boolean value)
      Whether the java.time (JSR 310) type OffsetTime should be bound natively to JDBC.

      Historically, jOOQ encoded the java.time types as strings to offer better compatibility with older JDBC drivers. By now, most drivers should support the java.time types. Using them may produce better performance both on the server and on the client side.

      This flag allows for reverting to pre-jOOQ 3.14 behaviour, where the default is to bind these types natively.

      For details, see https://github.com/jOOQ/jOOQ/issues/9902.

      Parameters:
      value - allowed object is Boolean
    • isFetchTriggerValuesAfterSQLServerOutput

      @Deprecated public Boolean isFetchTriggerValuesAfterSQLServerOutput()
      Deprecated.
      - 3.18.0 - [#13912] [#15316] - Use fetchTriggerValuesAfterReturning instead.
      Fetch trigger values after SQL Server OUTPUT clause.

      SQL Server OUTPUT statements do not support fetching trigger generated values. This is a limitation of the renderOutputForSQLServerReturningClause. An additional MERGE statement can run a second query if (and only if) the primary key has been included in the OUTPUT clause.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

      Returns:
      possible object is Boolean
    • setFetchTriggerValuesAfterSQLServerOutput

      @Deprecated public void setFetchTriggerValuesAfterSQLServerOutput(Boolean value)
      Deprecated.
      - 3.18.0 - [#13912] [#15316] - Use fetchTriggerValuesAfterReturning instead.
      Fetch trigger values after SQL Server OUTPUT clause.

      SQL Server OUTPUT statements do not support fetching trigger generated values. This is a limitation of the renderOutputForSQLServerReturningClause. An additional MERGE statement can run a second query if (and only if) the primary key has been included in the OUTPUT clause.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

      Parameters:
      value - allowed object is Boolean
    • getFetchTriggerValuesAfterReturning

      public FetchTriggerValuesAfterReturning getFetchTriggerValuesAfterReturning()
      Fetch trigger values after a RETURNING clause in dialects that don't have native support for this.

      SQL Server OUTPUT clauses do not support fetching trigger generated values. Neither do SQLite RETURNING clauses. An additional MERGE statement can run a second query if (and only if) the primary key has been included in the OUTPUT clause.

      Trigger meta data is only available in jOOQ's commercial editions. If setting this flag to WHEN_NEEDED in the jOOQ Open Source Edition, jOOQ will assume triggers are present.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

    • setFetchTriggerValuesAfterReturning

      public void setFetchTriggerValuesAfterReturning(FetchTriggerValuesAfterReturning value)
      Fetch trigger values after a RETURNING clause in dialects that don't have native support for this.

      SQL Server OUTPUT clauses do not support fetching trigger generated values. Neither do SQLite RETURNING clauses. An additional MERGE statement can run a second query if (and only if) the primary key has been included in the OUTPUT clause.

      Trigger meta data is only available in jOOQ's commercial editions. If setting this flag to WHEN_NEEDED in the jOOQ Open Source Edition, jOOQ will assume triggers are present.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

    • getFetchIntermediateResult

      public FetchIntermediateResult getFetchIntermediateResult()
      Whether to fetch data into intermediate Result instances.

      By default, a ResultQuery produces no intermediate Result instances if they are not explicitly requested by the caller, e.g. by calling ResultQuery.fetch(), or in the presence of ExecuteListener instances, which may require access to ExecuteContext.result(). This default behaviour helps avoid unnecessary allocations of possibly large data structures.

      Using this flag, fetching of intermediate results can be turned off even when execute listeners are present, or turned on even if they're absent.

    • setFetchIntermediateResult

      public void setFetchIntermediateResult(FetchIntermediateResult value)
      Whether to fetch data into intermediate Result instances.

      By default, a ResultQuery produces no intermediate Result instances if they are not explicitly requested by the caller, e.g. by calling ResultQuery.fetch(), or in the presence of ExecuteListener instances, which may require access to ExecuteContext.result(). This default behaviour helps avoid unnecessary allocations of possibly large data structures.

      Using this flag, fetching of intermediate results can be turned off even when execute listeners are present, or turned on even if they're absent.

    • isDiagnosticsDuplicateStatements

      public Boolean isDiagnosticsDuplicateStatements()
      Whether to run the DiagnosticsListener.duplicateStatements(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Returns:
      possible object is Boolean
    • setDiagnosticsDuplicateStatements

      public void setDiagnosticsDuplicateStatements(Boolean value)
      Whether to run the DiagnosticsListener.duplicateStatements(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsDuplicateStatementsUsingTransformPatterns

      public Boolean isDiagnosticsDuplicateStatementsUsingTransformPatterns()
      Whether to run the DiagnosticsListener.duplicateStatements(org.jooq.DiagnosticsContext) diagnostic with the transformPatterns feature activated.

      When transforming patterns, many more complex, duplicate SQL statements can be recognised than if simply parsing and re-rendering the statement. This flag turns on all transformation patterns, independently of their individual settings.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsDuplicateStatementsUsingTransformPatterns

      public void setDiagnosticsDuplicateStatementsUsingTransformPatterns(Boolean value)
      Whether to run the DiagnosticsListener.duplicateStatements(org.jooq.DiagnosticsContext) diagnostic with the transformPatterns feature activated.

      When transforming patterns, many more complex, duplicate SQL statements can be recognised than if simply parsing and re-rendering the statement. This flag turns on all transformation patterns, independently of their individual settings.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsMissingWasNullCall

      public Boolean isDiagnosticsMissingWasNullCall()
      Whether to run the DiagnosticsListener.missingWasNullCall(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Returns:
      possible object is Boolean
    • setDiagnosticsMissingWasNullCall

      public void setDiagnosticsMissingWasNullCall(Boolean value)
      Whether to run the DiagnosticsListener.missingWasNullCall(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsRepeatedStatements

      public Boolean isDiagnosticsRepeatedStatements()
      Whether to run the DiagnosticsListener.repeatedStatements(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Returns:
      possible object is Boolean
    • setDiagnosticsRepeatedStatements

      public void setDiagnosticsRepeatedStatements(Boolean value)
      Whether to run the DiagnosticsListener.repeatedStatements(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsConsecutiveAggregation

      public Boolean isDiagnosticsConsecutiveAggregation()
      Whether to run the DiagnosticsListener.consecutiveAggregation(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsConsecutiveAggregation

      public void setDiagnosticsConsecutiveAggregation(Boolean value)
      Whether to run the DiagnosticsListener.consecutiveAggregation(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsConcatenationInPredicate

      public Boolean isDiagnosticsConcatenationInPredicate()
      Whether to run the DiagnosticsListener.concatenationInPredicate(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsConcatenationInPredicate

      public void setDiagnosticsConcatenationInPredicate(Boolean value)
      Whether to run the DiagnosticsListener.concatenationInPredicate(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsPossiblyWrongExpression

      public Boolean isDiagnosticsPossiblyWrongExpression()
      Whether to run the DiagnosticsListener.possiblyWrongExpression(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsPossiblyWrongExpression

      public void setDiagnosticsPossiblyWrongExpression(Boolean value)
      Whether to run the DiagnosticsListener.possiblyWrongExpression(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsTooManyColumnsFetched

      public Boolean isDiagnosticsTooManyColumnsFetched()
      Whether to run the DiagnosticsListener.tooManyColumnsFetched(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Returns:
      possible object is Boolean
    • setDiagnosticsTooManyColumnsFetched

      public void setDiagnosticsTooManyColumnsFetched(Boolean value)
      Whether to run the DiagnosticsListener.tooManyColumnsFetched(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsTooManyRowsFetched

      public Boolean isDiagnosticsTooManyRowsFetched()
      Whether to run the DiagnosticsListener.tooManyRowsFetched(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Returns:
      possible object is Boolean
    • setDiagnosticsTooManyRowsFetched

      public void setDiagnosticsTooManyRowsFetched(Boolean value)
      Whether to run the DiagnosticsListener.tooManyRowsFetched(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsUnnecessaryWasNullCall

      public Boolean isDiagnosticsUnnecessaryWasNullCall()
      Whether to run the DiagnosticsListener.unnecessaryWasNullCall(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Returns:
      possible object is Boolean
    • setDiagnosticsUnnecessaryWasNullCall

      public void setDiagnosticsUnnecessaryWasNullCall(Boolean value)
      Whether to run the DiagnosticsListener.unnecessaryWasNullCall(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsPatterns

      public Boolean isDiagnosticsPatterns()
      Whether to run the various pattern transformation diagnostics.

      transformPatterns allows for applying numerous pattern transformations, which can be turned on separately when running diagnostics. This flag overrides the transformPatterns flag in the diagnostics context. Individual pattern flags still allow to enable / disable the pattern for diagnostics.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsPatterns

      public void setDiagnosticsPatterns(Boolean value)
      Whether to run the various pattern transformation diagnostics.

      transformPatterns allows for applying numerous pattern transformations, which can be turned on separately when running diagnostics. This flag overrides the transformPatterns flag in the diagnostics context. Individual pattern flags still allow to enable / disable the pattern for diagnostics.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsTrivialCondition

      public Boolean isDiagnosticsTrivialCondition()
      Whether to run the DiagnosticsListener.trivialCondition(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsTrivialCondition

      public void setDiagnosticsTrivialCondition(Boolean value)
      Whether to run the DiagnosticsListener.trivialCondition(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsNullCondition

      public Boolean isDiagnosticsNullCondition()
      Whether to run the
      invalid @link
      org.jooq.DiagnosticsListener#nullConditoin(org.jooq.DiagnosticsContext)
      diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setDiagnosticsNullCondition

      public void setDiagnosticsNullCondition(Boolean value)
      Whether to run the
      invalid @link
      org.jooq.DiagnosticsListener#nullConditoin(org.jooq.DiagnosticsContext)
      diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatterns

      public Boolean isTransformPatterns()
      Transform various syntax patterns to better versions, if possible.

      This flag enables the pattern transformation feature, which consists of several sub-flags that are all prefixed with "transformPatterns", e.g. transformPatternsTrim. While the sub-flags default to being enabled, and can be disabled on an individual basis, the global feature itself is disabled by default.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatterns

      public void setTransformPatterns(Boolean value)
      Transform various syntax patterns to better versions, if possible.

      This flag enables the pattern transformation feature, which consists of several sub-flags that are all prefixed with "transformPatterns", e.g. transformPatternsTrim. While the sub-flags default to being enabled, and can be disabled on an individual basis, the global feature itself is disabled by default.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsLogging

      public Boolean isTransformPatternsLogging()
      Activate debug logging of the transformPatterns feature.
      Returns:
      possible object is Boolean
    • setTransformPatternsLogging

      public void setTransformPatternsLogging(Boolean value)
      Activate debug logging of the transformPatterns feature.
      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnnecessaryDistinct

      public Boolean isTransformPatternsUnnecessaryDistinct()
      Transform SELECT DISTINCT a, b FROM t GROUP BY a, b to SELECT a, b FROM t GROUP BY a, b.

      The GROUP BY clause already removes duplicates, so if the DISTINCT clause contains at least all the columns from GROUP BY then it can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnnecessaryDistinct

      public void setTransformPatternsUnnecessaryDistinct(Boolean value)
      Transform SELECT DISTINCT a, b FROM t GROUP BY a, b to SELECT a, b FROM t GROUP BY a, b.

      The GROUP BY clause already removes duplicates, so if the DISTINCT clause contains at least all the columns from GROUP BY then it can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnnecessaryScalarSubquery

      public Boolean isTransformPatternsUnnecessaryScalarSubquery()
      Transform SELECT (SELECT 1) to SELECT 1.

      Scalar subqueries that don't have any content other than a SELECT clause are unnecessary and can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnnecessaryScalarSubquery

      public void setTransformPatternsUnnecessaryScalarSubquery(Boolean value)
      Transform SELECT (SELECT 1) to SELECT 1.

      Scalar subqueries that don't have any content other than a SELECT clause are unnecessary and can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnnecessaryInnerJoin

      public Boolean isTransformPatternsUnnecessaryInnerJoin()
      Transform SELECT * FROM t INNER JOIN u ON TRUE to SELECT * FROM t CROSS JOIN u.

      Some INNER JOIN expressions can be proven to be unnecessary.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnnecessaryInnerJoin

      public void setTransformPatternsUnnecessaryInnerJoin(Boolean value)
      Transform SELECT * FROM t INNER JOIN u ON TRUE to SELECT * FROM t CROSS JOIN u.

      Some INNER JOIN expressions can be proven to be unnecessary.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnnecessaryGroupByExpressions

      public Boolean isTransformPatternsUnnecessaryGroupByExpressions()
      Transform SELECT a, b FROM t GROUP BY a, a, b to SELECT a, b FROM t GROUP BY a, b.

      Duplicate GROUP BY expressions can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnnecessaryGroupByExpressions

      public void setTransformPatternsUnnecessaryGroupByExpressions(Boolean value)
      Transform SELECT a, b FROM t GROUP BY a, a, b to SELECT a, b FROM t GROUP BY a, b.

      Duplicate GROUP BY expressions can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnnecessaryOrderByExpressions

      public Boolean isTransformPatternsUnnecessaryOrderByExpressions()
      Transform SELECT a, b FROM t ORDER BY a, a, b to SELECT a, b FROM t ORDER BY a, b.

      Duplicate ORDER BY expressions can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnnecessaryOrderByExpressions

      public void setTransformPatternsUnnecessaryOrderByExpressions(Boolean value)
      Transform SELECT a, b FROM t ORDER BY a, a, b to SELECT a, b FROM t ORDER BY a, b.

      Duplicate ORDER BY expressions can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnnecessaryExistsSubqueryClauses

      public Boolean isTransformPatternsUnnecessaryExistsSubqueryClauses()
      Transform [ NOT ] EXISTS (SELECT DISTINCT a, b FROM t ORDER BY c LIMIT d) to [ NOT ] EXISTS (SELECT 1 FROM t).

      In EXISTS subqueries, quite a few SELECT clauses are meaningless, and can thus be removed. These include:

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnnecessaryExistsSubqueryClauses

      public void setTransformPatternsUnnecessaryExistsSubqueryClauses(Boolean value)
      Transform [ NOT ] EXISTS (SELECT DISTINCT a, b FROM t ORDER BY c LIMIT d) to [ NOT ] EXISTS (SELECT 1 FROM t).

      In EXISTS subqueries, quite a few SELECT clauses are meaningless, and can thus be removed. These include:

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCountConstant

      public Boolean isTransformPatternsCountConstant()
      Transform COUNT(1) or any other COUNT(const) to COUNT(*).

      There is no benefit to counting a constant expression. In fact, in some RDBMS, it might even be slightly slower, at least in benchmarks.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCountConstant

      public void setTransformPatternsCountConstant(Boolean value)
      Transform COUNT(1) or any other COUNT(const) to COUNT(*).

      There is no benefit to counting a constant expression. In fact, in some RDBMS, it might even be slightly slower, at least in benchmarks.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsTrim

      public Boolean isTransformPatternsTrim()
      Transform LTRIM(RTRIM(x)) or RTRIM(LTRIM(x)) to TRIM(x).

      Historically, a few dialects did not implement TRIM(x) or TRIM(BOTH FROM x), so users worked around this by wrapping LTRIM() and RTRIM() with each other. Maintaining this is usually undesirable, so this transformation helps remove the unwanted wrapping.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsTrim

      public void setTransformPatternsTrim(Boolean value)
      Transform LTRIM(RTRIM(x)) or RTRIM(LTRIM(x)) to TRIM(x).

      Historically, a few dialects did not implement TRIM(x) or TRIM(BOTH FROM x), so users worked around this by wrapping LTRIM() and RTRIM() with each other. Maintaining this is usually undesirable, so this transformation helps remove the unwanted wrapping.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNotAnd

      public Boolean isTransformPatternsNotAnd()
      Transform NOT(p AND q) to NOT(p) OR NOT(q).

      This transformation normalises a predicate using De Morgan's rules.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNotAnd

      public void setTransformPatternsNotAnd(Boolean value)
      Transform NOT(p AND q) to NOT(p) OR NOT(q).

      This transformation normalises a predicate using De Morgan's rules.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNotOr

      public Boolean isTransformPatternsNotOr()
      Transform NOT(p OR q) to NOT(p) AND NOT(q).

      This transformation normalises a predicate using De Morgan's rules.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNotOr

      public void setTransformPatternsNotOr(Boolean value)
      Transform NOT(p OR q) to NOT(p) AND NOT(q).

      This transformation normalises a predicate using De Morgan's rules.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNotNot

      public Boolean isTransformPatternsNotNot()
      Transform NOT(NOT(x)) to x.

      This transformation removes a redundant logic negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNotNot

      public void setTransformPatternsNotNot(Boolean value)
      Transform NOT(NOT(x)) to x.

      This transformation removes a redundant logic negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNotComparison

      public Boolean isTransformPatternsNotComparison()
      Transform NOT (a != b) to a = b, and similar comparisons.

      This transformation removes a redundant logical negation from the DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNotComparison

      public void setTransformPatternsNotComparison(Boolean value)
      Transform NOT (a != b) to a = b, and similar comparisons.

      This transformation removes a redundant logical negation from the DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNotNotDistinct

      public Boolean isTransformPatternsNotNotDistinct()
      Transform NOT (a IS NOT DISTINCT FROM b) to a IS DISTINCT FROM b.

      This transformation removes a redundant logical negation from the DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNotNotDistinct

      public void setTransformPatternsNotNotDistinct(Boolean value)
      Transform NOT (a IS NOT DISTINCT FROM b) to a IS DISTINCT FROM b.

      This transformation removes a redundant logical negation from the DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsDistinctFromNull

      public Boolean isTransformPatternsDistinctFromNull()
      Transform a IS [ NOT ] DISTINCT FROM NULL to a IS [ NOT ] NULL.

      This simplifies the much more verbose DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsDistinctFromNull

      public void setTransformPatternsDistinctFromNull(Boolean value)
      Transform a IS [ NOT ] DISTINCT FROM NULL to a IS [ NOT ] NULL.

      This simplifies the much more verbose DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNormaliseAssociativeOps

      public Boolean isTransformPatternsNormaliseAssociativeOps()
      Transform (a + b) + (c + d) to ((a + b) + c) + d.

      This transformation turns trees into lists, which greatly simplifies other tree traversal transformations. Some of those other transformations currently rely on this flag to be active.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNormaliseAssociativeOps

      public void setTransformPatternsNormaliseAssociativeOps(Boolean value)
      Transform (a + b) + (c + d) to ((a + b) + c) + d.

      This transformation turns trees into lists, which greatly simplifies other tree traversal transformations. Some of those other transformations currently rely on this flag to be active.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNormaliseInListSingleElementToComparison

      public Boolean isTransformPatternsNormaliseInListSingleElementToComparison()
      Transform x IN (a) to x = a and x NOT IN (a) to x != a.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNormaliseInListSingleElementToComparison

      public void setTransformPatternsNormaliseInListSingleElementToComparison(Boolean value)
      Transform x IN (a) to x = a and x NOT IN (a) to x != a.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNormaliseFieldCompareValue

      public Boolean isTransformPatternsNormaliseFieldCompareValue()
      Transform 1 = a to a = 1.

      This transformation inverses

      invalid @link
      TableField
      [op]
      invalid @link
      org.jooq.impl.QOM.Val
      comparisons, if they're not in that order.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNormaliseFieldCompareValue

      public void setTransformPatternsNormaliseFieldCompareValue(Boolean value)
      Transform 1 = a to a = 1.

      This transformation inverses

      invalid @link
      TableField
      [op]
      invalid @link
      org.jooq.impl.QOM.Val
      comparisons, if they're not in that order.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNormaliseCoalesceToNvl

      public Boolean isTransformPatternsNormaliseCoalesceToNvl()
      Transform 2 argument COALESCE(a, b) to NVL(a, b).

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNormaliseCoalesceToNvl

      public void setTransformPatternsNormaliseCoalesceToNvl(Boolean value)
      Transform 2 argument COALESCE(a, b) to NVL(a, b).

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsOrEqToIn

      public Boolean isTransformPatternsOrEqToIn()
      Transform x = c1 OR x = c2 to x IN (c1, c2).

      This transformation simplifies verbose OR predicates into simpler IN predicates.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsOrEqToIn

      public void setTransformPatternsOrEqToIn(Boolean value)
      Transform x = c1 OR x = c2 to x IN (c1, c2).

      This transformation simplifies verbose OR predicates into simpler IN predicates.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsAndNeToNotIn

      public Boolean isTransformPatternsAndNeToNotIn()
      Transform x != c1 AND x != c2 to x NOT IN (c1, c2).

      This transformation simplifies verbose AND predicates into simpler NOT IN predicates.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsAndNeToNotIn

      public void setTransformPatternsAndNeToNotIn(Boolean value)
      Transform x != c1 AND x != c2 to x NOT IN (c1, c2).

      This transformation simplifies verbose AND predicates into simpler NOT IN predicates.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsMergeOrComparison

      public Boolean isTransformPatternsMergeOrComparison()
      Transform x = a OR x > a to x >= a.

      This transformation merges multiple OR connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsMergeOrComparison

      public void setTransformPatternsMergeOrComparison(Boolean value)
      Transform x = a OR x > a to x >= a.

      This transformation merges multiple OR connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsMergeAndComparison

      public Boolean isTransformPatternsMergeAndComparison()
      Transform x >= a AND x invalid input: '<'= a to x = a.

      This transformation merges multiple AND connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsMergeAndComparison

      public void setTransformPatternsMergeAndComparison(Boolean value)
      Transform x >= a AND x invalid input: '<'= a to x = a.

      This transformation merges multiple AND connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsMergeInLists

      public Boolean isTransformPatternsMergeInLists()
      Transform x IN (a, b, c) AND x IN (b, c, d) to x IN (b, c).

      This transformation merges multiple OR connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsMergeInLists

      public void setTransformPatternsMergeInLists(Boolean value)
      Transform x IN (a, b, c) AND x IN (b, c, d) to x IN (b, c).

      This transformation merges multiple OR connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsMergeRangePredicates

      public Boolean isTransformPatternsMergeRangePredicates()
      Transform x >= a AND x invalid input: '<'= b to x BETWEEN a AND b.

      This transformation merges multiple AND connected range predicates to a single comparison using BETWEEN.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsMergeRangePredicates

      public void setTransformPatternsMergeRangePredicates(Boolean value)
      Transform x >= a AND x invalid input: '<'= b to x BETWEEN a AND b.

      This transformation merges multiple AND connected range predicates to a single comparison using BETWEEN.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsMergeBetweenSymmetricPredicates

      public Boolean isTransformPatternsMergeBetweenSymmetricPredicates()
      Transform x BETWEEN a AND b OR x BETWEEN b AND a to x BETWEEN SYMMETRIC a AND b.

      This transformation merges multiple OR connected BETWEEN predicates to a single comparison using BETWEEN SYMMETRIC.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsMergeBetweenSymmetricPredicates

      public void setTransformPatternsMergeBetweenSymmetricPredicates(Boolean value)
      Transform x BETWEEN a AND b OR x BETWEEN b AND a to x BETWEEN SYMMETRIC a AND b.

      This transformation merges multiple OR connected BETWEEN predicates to a single comparison using BETWEEN SYMMETRIC.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCaseSearchedToCaseSimple

      public Boolean isTransformPatternsCaseSearchedToCaseSimple()
      Transform a searched CASE WHEN x = .. WHEN x = .. to a simple CASE x WHEN … WHEN … expression.

      When a searched CASE expression always compares the same column to a value, then it can be simplified, possibly unlocking further transformations that are available only to the simple CASE expression.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCaseSearchedToCaseSimple

      public void setTransformPatternsCaseSearchedToCaseSimple(Boolean value)
      Transform a searched CASE WHEN x = .. WHEN x = .. to a simple CASE x WHEN … WHEN … expression.

      When a searched CASE expression always compares the same column to a value, then it can be simplified, possibly unlocking further transformations that are available only to the simple CASE expression.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCaseElseNull

      public Boolean isTransformPatternsCaseElseNull()
      Transform CASE … ELSE NULL removing the ELSE clause.

      CASE WHEN x THEN y ELSE NULL END is equivalent to CASE WHEN x THEN y END.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCaseElseNull

      public void setTransformPatternsCaseElseNull(Boolean value)
      Transform CASE … ELSE NULL removing the ELSE clause.

      CASE WHEN x THEN y ELSE NULL END is equivalent to CASE WHEN x THEN y END.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnreachableCaseClauses

      public Boolean isTransformPatternsUnreachableCaseClauses()
      Transform CASE by removing unreachable clauses.

      Case clauses can be proven to be unreachable, and thus removed:

      • CASE WHEN p THEN 1 WHEN TRUE THEN 2 WHEN q … ELSE … END is equivalent to CASE WHEN p THEN 1 ELSE 2 END
      • CASE WHEN p THEN 1 WHEN FALSE THEN 2 WHEN q .. ELSE .. END is equivalent to CASE WHEN p THEN 1 WHEN q … ELSE … END

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnreachableCaseClauses

      public void setTransformPatternsUnreachableCaseClauses(Boolean value)
      Transform CASE by removing unreachable clauses.

      Case clauses can be proven to be unreachable, and thus removed:

      • CASE WHEN p THEN 1 WHEN TRUE THEN 2 WHEN q … ELSE … END is equivalent to CASE WHEN p THEN 1 ELSE 2 END
      • CASE WHEN p THEN 1 WHEN FALSE THEN 2 WHEN q .. ELSE .. END is equivalent to CASE WHEN p THEN 1 WHEN q … ELSE … END

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsUnreachableDecodeClauses

      public Boolean isTransformPatternsUnreachableDecodeClauses()
      Transform DECODE by removing unreachable clauses.

      DECODE clauses can be proven to be unreachable, and thus removed:

      • DECODE(a, b, 1, c, 2, b, 3) is equivalent to DECODE(a, b, 1, c, 2)
      • DECODE(a, b, 1, c, 2, b, 3, 4) is equivalent to DECODE(a, b, 1, c, 2, 4)

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsUnreachableDecodeClauses

      public void setTransformPatternsUnreachableDecodeClauses(Boolean value)
      Transform DECODE by removing unreachable clauses.

      DECODE clauses can be proven to be unreachable, and thus removed:

      • DECODE(a, b, 1, c, 2, b, 3) is equivalent to DECODE(a, b, 1, c, 2)
      • DECODE(a, b, 1, c, 2, b, 3, 4) is equivalent to DECODE(a, b, 1, c, 2, 4)

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCaseDistinctToDecode

      public Boolean isTransformPatternsCaseDistinctToDecode()
      Transform CASE WHEN a IS NOT DISTINCT FROM b … to an equivalent DECODE function.

      When all WHEN clauses of a CASE expression use the DISTINCT predicate, then the CASE expression can be transformed into a DECODE function call:

      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 END is equivalent to DECODE(a, b, 1)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 ELSE 2 END is equivalent to DECODE(a, b, 1, 2)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 WHEN a IS NOT DISTINCT FROM c THEN 2 END is equivalent to DECODE(a, b, 1, c, 2)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 WHEN a IS NOT DISTINCT FROM c THEN 2 ELSE 3 END is equivalent to DECODE(a, b, 1, c, 2, 3)

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCaseDistinctToDecode

      public void setTransformPatternsCaseDistinctToDecode(Boolean value)
      Transform CASE WHEN a IS NOT DISTINCT FROM b … to an equivalent DECODE function.

      When all WHEN clauses of a CASE expression use the DISTINCT predicate, then the CASE expression can be transformed into a DECODE function call:

      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 END is equivalent to DECODE(a, b, 1)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 ELSE 2 END is equivalent to DECODE(a, b, 1, 2)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 WHEN a IS NOT DISTINCT FROM c THEN 2 END is equivalent to DECODE(a, b, 1, c, 2)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 WHEN a IS NOT DISTINCT FROM c THEN 2 ELSE 3 END is equivalent to DECODE(a, b, 1, c, 2, 3)

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCaseMergeWhenWhen

      public Boolean isTransformPatternsCaseMergeWhenWhen()
      Transform CASE WHEN a THEN x WHEN b THEN x END to CASE WHEN a OR b THEN x END.

      Two consecutive WHEN clauses can be merged, if their respective THEN clause is identical.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCaseMergeWhenWhen

      public void setTransformPatternsCaseMergeWhenWhen(Boolean value)
      Transform CASE WHEN a THEN x WHEN b THEN x END to CASE WHEN a OR b THEN x END.

      Two consecutive WHEN clauses can be merged, if their respective THEN clause is identical.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCaseMergeWhenElse

      public Boolean isTransformPatternsCaseMergeWhenElse()
      Transform CASE WHEN a THEN x WHEN b THEN y ELSE y END to CASE WHEN a THEN x ELSE y END.

      The ultimate WHEN clause can be merged with the ELSE, if their respective result is identical. If the WHEN clause is the only WHEN clause, then the entire CASE expression can be replaced by the ELSE clause content.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCaseMergeWhenElse

      public void setTransformPatternsCaseMergeWhenElse(Boolean value)
      Transform CASE WHEN a THEN x WHEN b THEN y ELSE y END to CASE WHEN a THEN x ELSE y END.

      The ultimate WHEN clause can be merged with the ELSE, if their respective result is identical. If the WHEN clause is the only WHEN clause, then the entire CASE expression can be replaced by the ELSE clause content.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsCaseToCaseAbbreviation

      public Boolean isTransformPatternsCaseToCaseAbbreviation()
      Transform CASE expressions to their respective abbreviations.

      Some CASE expressions have a shorter abbreviated form, such as COALESCE() or NULLIF().

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsCaseToCaseAbbreviation

      public void setTransformPatternsCaseToCaseAbbreviation(Boolean value)
      Transform CASE expressions to their respective abbreviations.

      Some CASE expressions have a shorter abbreviated form, such as COALESCE() or NULLIF().

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsSimplifyCaseAbbreviation

      public Boolean isTransformPatternsSimplifyCaseAbbreviation()
      Transform complex predicates into simpler CASE abbreviations.

      Some predicates can be simplified into case abbreviations, such as, for example

      • a IS NULL OR COALESCE(a = b, FALSE) to NULLIF(a, b) IS NULL
      • a IS NOT NULL AND COALESCE(a != b, TRUE) to NULLIF(a, b) IS NOT NULL

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsSimplifyCaseAbbreviation

      public void setTransformPatternsSimplifyCaseAbbreviation(Boolean value)
      Transform complex predicates into simpler CASE abbreviations.

      Some predicates can be simplified into case abbreviations, such as, for example

      • a IS NULL OR COALESCE(a = b, FALSE) to NULLIF(a, b) IS NULL
      • a IS NOT NULL AND COALESCE(a != b, TRUE) to NULLIF(a, b) IS NOT NULL

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsFlattenCaseAbbreviation

      public Boolean isTransformPatternsFlattenCaseAbbreviation()
      Flatten nested CASE abbreviations such as NVL or CASE.

      Nested CASE abbreviations can be flattened, as such:

      • NVL(NVL(a, b), c) to COALESCE(a, b, c)
      • COALESCE(a, ..., COALESCE(b, ..., c), ..., d) to COALESCE(a, …, b, …, c, ..., d)

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsFlattenCaseAbbreviation

      public void setTransformPatternsFlattenCaseAbbreviation(Boolean value)
      Flatten nested CASE abbreviations such as NVL or CASE.

      Nested CASE abbreviations can be flattened, as such:

      • NVL(NVL(a, b), c) to COALESCE(a, b, c)
      • COALESCE(a, ..., COALESCE(b, ..., c), ..., d) to COALESCE(a, …, b, …, c, ..., d)

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsFlattenDecode

      public Boolean isTransformPatternsFlattenDecode()
      Flatten nested DECODE functions.

      Nested DECODE functions can be flattened, as such:

      • DECODE(a, b, c, DECODE(a, d, e)) to DECODE(a, b, c, d, e)

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsFlattenDecode

      public void setTransformPatternsFlattenDecode(Boolean value)
      Flatten nested DECODE functions.

      Nested DECODE functions can be flattened, as such:

      • DECODE(a, b, c, DECODE(a, d, e)) to DECODE(a, b, c, d, e)

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsFlattenCase

      public Boolean isTransformPatternsFlattenCase()
      Transform CASE … ELSE CASE … by flattening the nested CASE.

      CASE WHEN a THEN b ELSE CASE WHEN c THEN d END END is equivalent to CASE WHEN a THEN b WHEN c THEN d END.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsFlattenCase

      public void setTransformPatternsFlattenCase(Boolean value)
      Transform CASE … ELSE CASE … by flattening the nested CASE.

      CASE WHEN a THEN b ELSE CASE WHEN c THEN d END END is equivalent to CASE WHEN a THEN b WHEN c THEN d END.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsTrivialCaseAbbreviation

      public Boolean isTransformPatternsTrivialCaseAbbreviation()
      Transform trivial case abbreviations like NVL(NULL, a) to a.

      This transformation removes any trivial case abbreviations, such as NVL(), COALESCE(), NULLIF(), etc.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsTrivialCaseAbbreviation

      public void setTransformPatternsTrivialCaseAbbreviation(Boolean value)
      Transform trivial case abbreviations like NVL(NULL, a) to a.

      This transformation removes any trivial case abbreviations, such as NVL(), COALESCE(), NULLIF(), etc.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsTrivialPredicates

      public Boolean isTransformPatternsTrivialPredicates()
      Transform trivial predicates like 1 = 1 to TRUE.

      This transformation removes any trivial predicates.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsTrivialPredicates

      public void setTransformPatternsTrivialPredicates(Boolean value)
      Transform trivial predicates like 1 = 1 to TRUE.

      This transformation removes any trivial predicates.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsTrivialBitwiseOperations

      public Boolean isTransformPatternsTrivialBitwiseOperations()
      Transform trivial bitwise comparisons like BIT_OR(a, 0) to a.

      This transformation removes any trivial predicates.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsTrivialBitwiseOperations

      public void setTransformPatternsTrivialBitwiseOperations(Boolean value)
      Transform trivial bitwise comparisons like BIT_OR(a, 0) to a.

      This transformation removes any trivial predicates.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsBitSet

      public Boolean isTransformPatternsBitSet()
      Transform bitwise operations to an equivalent BIT_SET(a, b) or BIT_SET(a, b, c) expression.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsBitSet

      public void setTransformPatternsBitSet(Boolean value)
      Transform bitwise operations to an equivalent BIT_SET(a, b) or BIT_SET(a, b, c) expression.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsBitGet

      public Boolean isTransformPatternsBitGet()
      Transform bitwise operations to an equivalent BIT_GET(a, b) expression.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsBitGet

      public void setTransformPatternsBitGet(Boolean value)
      Transform bitwise operations to an equivalent BIT_GET(a, b) expression.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsScalarSubqueryCountAsteriskGtZero

      public Boolean isTransformPatternsScalarSubqueryCountAsteriskGtZero()
      Transform predicates comparing scalar subqueries with a count (SELECT COUNT(*) …) > 0 to equivalent EXISTS (SELECT 1 …).

      Scalar subqueries that count rows and whose count is compared to 0 can be transformed into equivalent, but likely cheaper to execute EXISTS queries.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsScalarSubqueryCountAsteriskGtZero

      public void setTransformPatternsScalarSubqueryCountAsteriskGtZero(Boolean value)
      Transform predicates comparing scalar subqueries with a count (SELECT COUNT(*) …) > 0 to equivalent EXISTS (SELECT 1 …).

      Scalar subqueries that count rows and whose count is compared to 0 can be transformed into equivalent, but likely cheaper to execute EXISTS queries.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsScalarSubqueryCountExpressionGtZero

      public Boolean isTransformPatternsScalarSubqueryCountExpressionGtZero()
      Transform predicates comparing scalar subqueries with a count (SELECT COUNT(expr) …) > 0 to equivalent EXISTS (SELECT 1 … WHERE expr IS NOT NULL).

      Scalar subqueries that count non-null expressions and whose count is compared to 0 can be transformed into equivalent, but likely cheaper to execute EXISTS queries.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsScalarSubqueryCountExpressionGtZero

      public void setTransformPatternsScalarSubqueryCountExpressionGtZero(Boolean value)
      Transform predicates comparing scalar subqueries with a count (SELECT COUNT(expr) …) > 0 to equivalent EXISTS (SELECT 1 … WHERE expr IS NOT NULL).

      Scalar subqueries that count non-null expressions and whose count is compared to 0 can be transformed into equivalent, but likely cheaper to execute EXISTS queries.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsEmptyScalarSubquery

      public Boolean isTransformPatternsEmptyScalarSubquery()
      Transform empty scalar subqueries like (SELECT 1 WHERE FALSE) to NULL.

      Scalar subqueries that are guaranteed to produce no results can be replaced by a NULL value.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsEmptyScalarSubquery

      public void setTransformPatternsEmptyScalarSubquery(Boolean value)
      Transform empty scalar subqueries like (SELECT 1 WHERE FALSE) to NULL.

      Scalar subqueries that are guaranteed to produce no results can be replaced by a NULL value.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNegNeg

      public Boolean isTransformPatternsNegNeg()
      Transform -(-(x)) to x

      This transformation removes a redundant arithmetic negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNegNeg

      public void setTransformPatternsNegNeg(Boolean value)
      Transform -(-(x)) to x

      This transformation removes a redundant arithmetic negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsBitNotBitNot

      public Boolean isTransformPatternsBitNotBitNot()
      Transform ~(~(x)) to x.

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsBitNotBitNot

      public void setTransformPatternsBitNotBitNot(Boolean value)
      Transform ~(~(x)) to x.

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsBitNotBitNand

      public Boolean isTransformPatternsBitNotBitNand()
      Transform ~(bitnand(x, y)) to bitand(x, y) and ~(bitand(x, y) to bitnand(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsBitNotBitNand

      public void setTransformPatternsBitNotBitNand(Boolean value)
      Transform ~(bitnand(x, y)) to bitand(x, y) and ~(bitand(x, y) to bitnand(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsBitNotBitNor

      public Boolean isTransformPatternsBitNotBitNor()
      Transform ~(bitnor(x, y)) to bitor(x, y) and ~(bitor(x, y) to bitnor(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsBitNotBitNor

      public void setTransformPatternsBitNotBitNor(Boolean value)
      Transform ~(bitnor(x, y)) to bitor(x, y) and ~(bitor(x, y) to bitnor(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsBitNotBitXNor

      public Boolean isTransformPatternsBitNotBitXNor()
      Transform ~(bitxnor(x, y)) to bitxor(x, y) and ~(bitxor(x, y) to bitxnor(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsBitNotBitXNor

      public void setTransformPatternsBitNotBitXNor(Boolean value)
      Transform ~(bitxnor(x, y)) to bitxor(x, y) and ~(bitxor(x, y) to bitxnor(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsNullOnNullInput

      public Boolean isTransformPatternsNullOnNullInput()
      Any {org.jooq.impl.QOM.UReturnsNullOnNullInput} function or expression with NULL arguments can be replaced by NULL.

      There are many built-in SQL functions and operators with a RETURNS NULL ON NULL INPUT property, e.g.

      • ABS(NULL)
      • MOD(NULL, 1)
      • NULL + 1

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsNullOnNullInput

      public void setTransformPatternsNullOnNullInput(Boolean value)
      Any {org.jooq.impl.QOM.UReturnsNullOnNullInput} function or expression with NULL arguments can be replaced by NULL.

      There are many built-in SQL functions and operators with a RETURNS NULL ON NULL INPUT property, e.g.

      • ABS(NULL)
      • MOD(NULL, 1)
      • NULL + 1

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsIdempotentFunctionRepetition

      public Boolean isTransformPatternsIdempotentFunctionRepetition()
      Transform all repetitions of idempotent functions, such as UPPER(UPPER(s)) to UPPER(s).

      Idempotent functions that are covered so far, include:

      • LTRIM(LTRIM(s)) to LTRIM(s)
      • LTRIM(TRIM(s)) to TRIM(s)
      • RTRIM(RTRIM(s)) to RTRIM(s)
      • RTRIM(TRIM(s)) to TRIM(s)
      • TRIM(LTRIM(s)) to TRIM(s)
      • TRIM(RTRIM(s)) to TRIM(s)
      • UPPER(UPPER(s)) to UPPER(s)
      • LOWER(LOWER(s)) to LOWER(s)

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsIdempotentFunctionRepetition

      public void setTransformPatternsIdempotentFunctionRepetition(Boolean value)
      Transform all repetitions of idempotent functions, such as UPPER(UPPER(s)) to UPPER(s).

      Idempotent functions that are covered so far, include:

      • LTRIM(LTRIM(s)) to LTRIM(s)
      • LTRIM(TRIM(s)) to TRIM(s)
      • RTRIM(RTRIM(s)) to RTRIM(s)
      • RTRIM(TRIM(s)) to TRIM(s)
      • TRIM(LTRIM(s)) to TRIM(s)
      • TRIM(RTRIM(s)) to TRIM(s)
      • UPPER(UPPER(s)) to UPPER(s)
      • LOWER(LOWER(s)) to LOWER(s)

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsArithmeticComparisons

      public Boolean isTransformPatternsArithmeticComparisons()
      Transform a + 1 = 2 to a = 2 - 1, and other transformations.

      It is usually best to compare single columns with constants or expressions to encourage index usage. While function based indexes are possible in some RDBMS, ordinary indexes are more reusable and should be preferred.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsArithmeticComparisons

      public void setTransformPatternsArithmeticComparisons(Boolean value)
      Transform a + 1 = 2 to a = 2 - 1, and other transformations.

      It is usually best to compare single columns with constants or expressions to encourage index usage. While function based indexes are possible in some RDBMS, ordinary indexes are more reusable and should be preferred.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsArithmeticExpressions

      public Boolean isTransformPatternsArithmeticExpressions()
      Transform 1 / y * x to x / y, and other transformations.

      This transformation simplifies arithmetic expressions.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsArithmeticExpressions

      public void setTransformPatternsArithmeticExpressions(Boolean value)
      Transform 1 / y * x to x / y, and other transformations.

      This transformation simplifies arithmetic expressions.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsTrigonometricFunctions

      public Boolean isTransformPatternsTrigonometricFunctions()
      Transform SIN(x) / COS(x) to TAN(x), and other transformations.

      This transformation turns expanded trignonometric function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsTrigonometricFunctions

      public void setTransformPatternsTrigonometricFunctions(Boolean value)
      Transform SIN(x) / COS(x) to TAN(x), and other transformations.

      This transformation turns expanded trignonometric function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsLogarithmicFunctions

      public Boolean isTransformPatternsLogarithmicFunctions()
      Transform LN(value) / LN(base) to LOG(base, value), and other transformations.

      This transformation turns expanded logarithmic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsLogarithmicFunctions

      public void setTransformPatternsLogarithmicFunctions(Boolean value)
      Transform LN(value) / LN(base) to LOG(base, value), and other transformations.

      This transformation turns expanded logarithmic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsHyperbolicFunctions

      public Boolean isTransformPatternsHyperbolicFunctions()
      Transform (EXP(x) - EXP(-x)) / 2 to SINH(x), and other transformations.

      This transformation turns expanded hyperbolic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsHyperbolicFunctions

      public void setTransformPatternsHyperbolicFunctions(Boolean value)
      Transform (EXP(x) - EXP(-x)) / 2 to SINH(x), and other transformations.

      This transformation turns expanded hyperbolic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformPatternsInverseHyperbolicFunctions

      public Boolean isTransformPatternsInverseHyperbolicFunctions()
      Transform LN(x + SQRT(SQUARE(x) + 1)) to ASINH(x), and other transformations.

      This transformation turns expanded inverse hyperbolic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformPatternsInverseHyperbolicFunctions

      public void setTransformPatternsInverseHyperbolicFunctions(Boolean value)
      Transform LN(x + SQRT(SQUARE(x) + 1)) to ASINH(x), and other transformations.

      This transformation turns expanded inverse hyperbolic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformInlineBindValuesForFieldComparisons

      public Boolean isTransformInlineBindValuesForFieldComparisons()
      Transform QOM.CompareCondition and a few other types of condition to inline their bind values, in case they match

      Historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. For backwards compatibility with older RDBMS versions, ANSI joins in jOOQ code may be converted to equivalent table lists in generated SQL using this flag.

      This flag has a limited implementation that supports inner joins (in most cases) and outer joins (only for simple comparison predicates).

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformInlineBindValuesForFieldComparisons

      public void setTransformInlineBindValuesForFieldComparisons(Boolean value)
      Transform QOM.CompareCondition and a few other types of condition to inline their bind values, in case they match

      Historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. For backwards compatibility with older RDBMS versions, ANSI joins in jOOQ code may be converted to equivalent table lists in generated SQL using this flag.

      This flag has a limited implementation that supports inner joins (in most cases) and outer joins (only for simple comparison predicates).

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • isTransformAnsiJoinToTableLists

      public Boolean isTransformAnsiJoinToTableLists()
      Transform ANSI join to table lists if possible.

      Historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. For backwards compatibility with older RDBMS versions, ANSI joins in jOOQ code may be converted to equivalent table lists in generated SQL using this flag.

      This flag has a limited implementation that supports inner joins (in most cases) and outer joins (only for simple comparison predicates).

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformAnsiJoinToTableLists

      public void setTransformAnsiJoinToTableLists(Boolean value)
      Transform ANSI join to table lists if possible.

      Historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. For backwards compatibility with older RDBMS versions, ANSI joins in jOOQ code may be converted to equivalent table lists in generated SQL using this flag.

      This flag has a limited implementation that supports inner joins (in most cases) and outer joins (only for simple comparison predicates).

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • getTransformInConditionSubqueryWithLimitToDerivedTable

      @Deprecated public Transformation getTransformInConditionSubqueryWithLimitToDerivedTable()
      Deprecated.
      - 3.18.0 - [#14634] - The configuration of this transformation is deprecated. It will no longer be commercially available only, but apply also to the jOOQ Open Source Edition, when required.
      Transform a subquery from an IN condition with LIMIT to an equivalent derived table.

      This transformation works around a known MySQL limitation "ERROR 1235 (42000): This version of MySQL doesn't yet support 'LIMIT invalid input: '&' IN/ALL/ANY/SOME subquery'"

      This feature is available in the commercial distribution only.

    • setTransformInConditionSubqueryWithLimitToDerivedTable

      @Deprecated public void setTransformInConditionSubqueryWithLimitToDerivedTable(Transformation value)
      Deprecated.
      - 3.18.0 - [#14634] - The configuration of this transformation is deprecated. It will no longer be commercially available only, but apply also to the jOOQ Open Source Edition, when required.
      Transform a subquery from an IN condition with LIMIT to an equivalent derived table.

      This transformation works around a known MySQL limitation "ERROR 1235 (42000): This version of MySQL doesn't yet support 'LIMIT invalid input: '&' IN/ALL/ANY/SOME subquery'"

      This feature is available in the commercial distribution only.

    • getTransformQualify

      public Transformation getTransformQualify()
      Transform the QUALIFY clause to an equivalent derived table to filter on window functions.

      This feature is available in the commercial distribution only.

    • setTransformQualify

      public void setTransformQualify(Transformation value)
      Transform the QUALIFY clause to an equivalent derived table to filter on window functions.

      This feature is available in the commercial distribution only.

    • isTransformTableListsToAnsiJoin

      public Boolean isTransformTableListsToAnsiJoin()
      Transform table lists to ANSI join if possible.

      (Very) historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. Migrating such join syntax is tedious. The jOOQ parser can parse the old syntax and this flag enables the transformation to ANSI join syntax.

      This feature is available in the commercial distribution only.

      Returns:
      possible object is Boolean
    • setTransformTableListsToAnsiJoin

      public void setTransformTableListsToAnsiJoin(Boolean value)
      Transform table lists to ANSI join if possible.

      (Very) historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. Migrating such join syntax is tedious. The jOOQ parser can parse the old syntax and this flag enables the transformation to ANSI join syntax.

      This feature is available in the commercial distribution only.

      Parameters:
      value - allowed object is Boolean
    • getTransformRownum

      public Transformation getTransformRownum()
      Transform ROWNUM expressions to corresponding LIMIT clauses or ROW_NUMBER() expressions.

      In Oracle 11g and less, ROWNUM filtering was the most popular way to paginate. This pseudo column is not supported in other RDBMS, and should be replaced in Oracle 12c by the FETCH clause or ROW_NUMBER() OVER () filtering. This transformation allows for replacing such a filter by equivalent SQL, if possible.

      This feature is available in the commercial distribution only.

    • setTransformRownum

      public void setTransformRownum(Transformation value)
      Transform ROWNUM expressions to corresponding LIMIT clauses or ROW_NUMBER() expressions.

      In Oracle 11g and less, ROWNUM filtering was the most popular way to paginate. This pseudo column is not supported in other RDBMS, and should be replaced in Oracle 12c by the FETCH clause or ROW_NUMBER() OVER () filtering. This transformation allows for replacing such a filter by equivalent SQL, if possible.

      This feature is available in the commercial distribution only.

    • getTransformUnneededArithmeticExpressions

      public TransformUnneededArithmeticExpressions getTransformUnneededArithmeticExpressions()
      Transform arithmetic expressions on literals and bind variables.

      Arithmetic expressions may be implemented by the user, or arise from emulations from within jOOQ. Expressions on literals and bind variables could be evaluated in the client prior to generating SQL.

      This feature is available in the commercial distribution only.

    • setTransformUnneededArithmeticExpressions

      public void setTransformUnneededArithmeticExpressions(TransformUnneededArithmeticExpressions value)
      Transform arithmetic expressions on literals and bind variables.

      Arithmetic expressions may be implemented by the user, or arise from emulations from within jOOQ. Expressions on literals and bind variables could be evaluated in the client prior to generating SQL.

      This feature is available in the commercial distribution only.

    • getTransformGroupByColumnIndex

      public Transformation getTransformGroupByColumnIndex()
      Transform GROUP BY [column index] clauses by substituting the column index.

      Not all dialects support grouping by column index, which is a convenient but also a bit confusing feature of some dialects. jOOQ can transform the syntax into an equivalent syntax where the referenced SELECT expression is duplicated into the GROUP BY clause.

      This feature is available in the commercial distribution only.

    • setTransformGroupByColumnIndex

      public void setTransformGroupByColumnIndex(Transformation value)
      Transform GROUP BY [column index] clauses by substituting the column index.

      Not all dialects support grouping by column index, which is a convenient but also a bit confusing feature of some dialects. jOOQ can transform the syntax into an equivalent syntax where the referenced SELECT expression is duplicated into the GROUP BY clause.

      This feature is available in the commercial distribution only.

    • getTransformInlineCTE

      public Transformation getTransformInlineCTE()
      Transform Common Table Expressions (CTE) by inlining their WITH clause definition to wherever they're referenced.

      Non-recursive CTE are just syntax sugar for inline views (derived tables). When they're not supported natively, jOOQ can simply inline their definition to wherever they're referenced.

      This feature is available in the commercial distribution only.

    • setTransformInlineCTE

      public void setTransformInlineCTE(Transformation value)
      Transform Common Table Expressions (CTE) by inlining their WITH clause definition to wherever they're referenced.

      Non-recursive CTE are just syntax sugar for inline views (derived tables). When they're not supported natively, jOOQ can simply inline their definition to wherever they're referenced.

      This feature is available in the commercial distribution only.

    • getBackslashEscaping

      public BackslashEscaping getBackslashEscaping()
      Whether string literals should be escaped with backslash.
    • setBackslashEscaping

      public void setBackslashEscaping(BackslashEscaping value)
      Whether string literals should be escaped with backslash.
    • getParamType

      public ParamType getParamType()
      Specify how bind variables are to be rendered.

      Possibilities include: - question marks - named parameters - named or inlined parameters - inlined parameters This value is overridden by statementType == STATIC_STATEMENT, in case of which, this defaults to INLINED

    • setParamType

      public void setParamType(ParamType value)
      Specify how bind variables are to be rendered.

      Possibilities include: - question marks - named parameters - named or inlined parameters - inlined parameters This value is overridden by statementType == STATIC_STATEMENT, in case of which, this defaults to INLINED

    • getParamCastMode

      public ParamCastMode getParamCastMode()
      Whether rendered bind values should be cast to their respective type.
    • setParamCastMode

      public void setParamCastMode(ParamCastMode value)
      Whether rendered bind values should be cast to their respective type.
    • getStatementType

      public StatementType getStatementType()
      The type of statement that is to be executed.
    • setStatementType

      public void setStatementType(StatementType value)
      The type of statement that is to be executed.
    • getInlineThreshold

      public Integer getInlineThreshold()
      The maximum number of allowed bind variables before inlining all values where 0 uses the dialect defaults:
    • setInlineThreshold

      public void setInlineThreshold(Integer value)
      The maximum number of allowed bind variables before inlining all values where 0 uses the dialect defaults:
    • getTransactionListenerStartInvocationOrder

      public InvocationOrder getTransactionListenerStartInvocationOrder()
      The order of invocation for [action]start() methods registered TransactionListeners.
    • setTransactionListenerStartInvocationOrder

      public void setTransactionListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered TransactionListeners.
    • getTransactionListenerEndInvocationOrder

      public InvocationOrder getTransactionListenerEndInvocationOrder()
      The order of invocation for [action]end() methods registered TransactionListeners.
    • setTransactionListenerEndInvocationOrder

      public void setTransactionListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered TransactionListeners.
    • getMigrationListenerStartInvocationOrder

      public InvocationOrder getMigrationListenerStartInvocationOrder()
      The order of invocation for [action]start() methods registered MigrationListeners.
    • setMigrationListenerStartInvocationOrder

      public void setMigrationListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered MigrationListeners.
    • getMigrationListenerEndInvocationOrder

      public InvocationOrder getMigrationListenerEndInvocationOrder()
      The order of invocation for [action]end() methods registered MigrationListeners.
    • setMigrationListenerEndInvocationOrder

      public void setMigrationListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered MigrationListeners.
    • getVisitListenerStartInvocationOrder

      public InvocationOrder getVisitListenerStartInvocationOrder()
      The order of invocation for [action]start() methods registered VisitListeners.
    • setVisitListenerStartInvocationOrder

      public void setVisitListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered VisitListeners.
    • getVisitListenerEndInvocationOrder

      public InvocationOrder getVisitListenerEndInvocationOrder()
      The order of invocation for [action]end() methods registered VisitListeners.
    • setVisitListenerEndInvocationOrder

      public void setVisitListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered VisitListeners.
    • getRecordListenerStartInvocationOrder

      public InvocationOrder getRecordListenerStartInvocationOrder()
      The order of invocation for [action]start() methods registered RecordListeners.
    • setRecordListenerStartInvocationOrder

      public void setRecordListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered RecordListeners.
    • getRecordListenerEndInvocationOrder

      public InvocationOrder getRecordListenerEndInvocationOrder()
      The order of invocation for [action]end() methods registered RecordListeners.
    • setRecordListenerEndInvocationOrder

      public void setRecordListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered RecordListeners.
    • getExecuteListenerStartInvocationOrder

      public InvocationOrder getExecuteListenerStartInvocationOrder()
      The order of invocation for [action]start() methods registered ExecuteListeners.
    • setExecuteListenerStartInvocationOrder

      public void setExecuteListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered ExecuteListeners.
    • getExecuteListenerEndInvocationOrder

      public InvocationOrder getExecuteListenerEndInvocationOrder()
      The order of invocation for [action]end() methods registered ExecuteListeners.
    • setExecuteListenerEndInvocationOrder

      public void setExecuteListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered ExecuteListeners.
    • isExecuteLogging

      public Boolean isExecuteLogging()
      When set to true, this will add jOOQ's default LoggerListener for debug logging. This is meant for use in development only.
      Returns:
      possible object is Boolean
    • setExecuteLogging

      public void setExecuteLogging(Boolean value)
      When set to true, this will add jOOQ's default LoggerListener for debug logging. This is meant for use in development only.
      Parameters:
      value - allowed object is Boolean
    • isExecuteLoggingSQLExceptions

      public Boolean isExecuteLoggingSQLExceptions()
      [#14420] Whether constraint violations and other SQLException should produce additional log information about the column name and data causing the problem. Unlike executeLogging, this is meant for use in production as well as development. This feature is available only in commercial distributions.
      Returns:
      possible object is Boolean
    • setExecuteLoggingSQLExceptions

      public void setExecuteLoggingSQLExceptions(Boolean value)
      [#14420] Whether constraint violations and other SQLException should produce additional log information about the column name and data causing the problem. Unlike executeLogging, this is meant for use in production as well as development. This feature is available only in commercial distributions.
      Parameters:
      value - allowed object is Boolean
    • isDiagnosticsLogging

      public Boolean isDiagnosticsLogging()
      When set to true, this will add jOOQ's default logging DiagnosticsListeners.
      Returns:
      possible object is Boolean
    • setDiagnosticsLogging

      public void setDiagnosticsLogging(Boolean value)
      When set to true, this will add jOOQ's default logging DiagnosticsListeners.
      Parameters:
      value - allowed object is Boolean
    • getDiagnosticsConnection

      public DiagnosticsConnection getDiagnosticsConnection()
      Whether to activate the DiagnosticsConnection, explicit by DEFAULT, implicit if ON, or turned OFF entirely.
    • setDiagnosticsConnection

      public void setDiagnosticsConnection(DiagnosticsConnection value)
      Whether to activate the DiagnosticsConnection, explicit by DEFAULT, implicit if ON, or turned OFF entirely.
    • isUpdateRecordVersion

      public Boolean isUpdateRecordVersion()
      Whether store(), insert(), and update() methods should update the record version prior to the operation, for use with executeWithOptimisticLocking.
      Returns:
      possible object is Boolean
    • setUpdateRecordVersion

      public void setUpdateRecordVersion(Boolean value)
      Whether store(), insert(), and update() methods should update the record version prior to the operation, for use with executeWithOptimisticLocking.
      Parameters:
      value - allowed object is Boolean
    • isUpdateRecordTimestamp

      public Boolean isUpdateRecordTimestamp()
      Whether store(), insert(), and update() methods should update the record timestamp prior to the operation, for use with executeWithOptimisticLocking.
      Returns:
      possible object is Boolean
    • setUpdateRecordTimestamp

      public void setUpdateRecordTimestamp(Boolean value)
      Whether store(), insert(), and update() methods should update the record timestamp prior to the operation, for use with executeWithOptimisticLocking.
      Parameters:
      value - allowed object is Boolean
    • isExecuteWithOptimisticLocking

      public Boolean isExecuteWithOptimisticLocking()
      Whether store() and delete() methods should be executed with optimistic locking.
      Returns:
      possible object is Boolean
    • setExecuteWithOptimisticLocking

      public void setExecuteWithOptimisticLocking(Boolean value)
      Whether store() and delete() methods should be executed with optimistic locking.
      Parameters:
      value - allowed object is Boolean
    • isExecuteWithOptimisticLockingExcludeUnversioned

      public Boolean isExecuteWithOptimisticLockingExcludeUnversioned()
      Whether store() and delete() methods should be executed with optimistic locking also on "unversioned" tables, i.e. on tables that do not have a version and/or timestamp column.

      This flag has no effect when "executeWithOptimisticLocking" is turned off.

      Returns:
      possible object is Boolean
    • setExecuteWithOptimisticLockingExcludeUnversioned

      public void setExecuteWithOptimisticLockingExcludeUnversioned(Boolean value)
      Whether store() and delete() methods should be executed with optimistic locking also on "unversioned" tables, i.e. on tables that do not have a version and/or timestamp column.

      This flag has no effect when "executeWithOptimisticLocking" is turned off.

      Parameters:
      value - allowed object is Boolean
    • isAttachRecords

      public Boolean isAttachRecords()
      Whether fetched records should be attached to the fetching configuration.
      Returns:
      possible object is Boolean
    • setAttachRecords

      public void setAttachRecords(Boolean value)
      Whether fetched records should be attached to the fetching configuration.
      Parameters:
      value - allowed object is Boolean
    • isInsertUnchangedRecords

      public Boolean isInsertUnchangedRecords()
      Whether TableRecord.insert() calls should be executed if the record is unchanged. This also affects the INSERT part of UpdatableRecord.store() and UpdatableRecord.merge() calls.
      Returns:
      possible object is Boolean
    • setInsertUnchangedRecords

      public void setInsertUnchangedRecords(Boolean value)
      Whether TableRecord.insert() calls should be executed if the record is unchanged. This also affects the INSERT part of UpdatableRecord.store() and UpdatableRecord.merge() calls.
      Parameters:
      value - allowed object is Boolean
    • getUpdateUnchangedRecords

      public UpdateUnchangedRecords getUpdateUnchangedRecords()
      Whether UpdatableRecord.update() calls should be executed if the record is unchanged. This also affects the UPDATE part of UpdatableRecord.store() and UpdatableRecord.merge() calls.
    • setUpdateUnchangedRecords

      public void setUpdateUnchangedRecords(UpdateUnchangedRecords value)
      Whether UpdatableRecord.update() calls should be executed if the record is unchanged. This also affects the UPDATE part of UpdatableRecord.store() and UpdatableRecord.merge() calls.
    • isUpdatablePrimaryKeys

      public Boolean isUpdatablePrimaryKeys()
      Whether primary key values are deemed to be "updatable" in jOOQ.

      Setting this to "true" will allow for updating primary key values through UpdatableRecord.store() and UpdatableRecord.update().

      Returns:
      possible object is Boolean
    • setUpdatablePrimaryKeys

      public void setUpdatablePrimaryKeys(Boolean value)
      Whether primary key values are deemed to be "updatable" in jOOQ.

      Setting this to "true" will allow for updating primary key values through UpdatableRecord.store() and UpdatableRecord.update().

      Parameters:
      value - allowed object is Boolean
    • isReflectionCaching

      public Boolean isReflectionCaching()
      Whether reflection information should be cached in the configuration.
      Returns:
      possible object is Boolean
    • setReflectionCaching

      public void setReflectionCaching(Boolean value)
      Whether reflection information should be cached in the configuration.
      Parameters:
      value - allowed object is Boolean
    • isCacheRecordMappers

      public Boolean isCacheRecordMappers()
      Whether record mappers should be cached in the configuration.
      Returns:
      possible object is Boolean
    • setCacheRecordMappers

      public void setCacheRecordMappers(Boolean value)
      Whether record mappers should be cached in the configuration.
      Parameters:
      value - allowed object is Boolean
    • isCacheParsingConnection

      public Boolean isCacheParsingConnection()
      Whether parsing connection translations should be cached in the configuration.
      Returns:
      possible object is Boolean
    • setCacheParsingConnection

      public void setCacheParsingConnection(Boolean value)
      Whether parsing connection translations should be cached in the configuration.
      Parameters:
      value - allowed object is Boolean
    • getCacheParsingConnectionLRUCacheSize

      public Integer getCacheParsingConnectionLRUCacheSize()
      The default implementation of the ParsingConnection cache's LRU cache size.
    • setCacheParsingConnectionLRUCacheSize

      public void setCacheParsingConnectionLRUCacheSize(Integer value)
      The default implementation of the ParsingConnection cache's LRU cache size.
    • isCachePreparedStatementInLoader

      public Boolean isCachePreparedStatementInLoader()
      Whether JDBC PreparedStatement instances should be cached in loader API.
      Returns:
      possible object is Boolean
    • setCachePreparedStatementInLoader

      public void setCachePreparedStatementInLoader(Boolean value)
      Whether JDBC PreparedStatement instances should be cached in loader API.
      Parameters:
      value - allowed object is Boolean
    • getThrowExceptions

      public ThrowExceptions getThrowExceptions()
      A strategy defining how exceptions from the database / JDBC driver should be propagated
    • setThrowExceptions

      public void setThrowExceptions(ThrowExceptions value)
      A strategy defining how exceptions from the database / JDBC driver should be propagated
    • isFetchWarnings

      public Boolean isFetchWarnings()
      Whether warnings should be fetched after each query execution.
      Returns:
      possible object is Boolean
    • setFetchWarnings

      public void setFetchWarnings(Boolean value)
      Whether warnings should be fetched after each query execution.
      Parameters:
      value - allowed object is Boolean
    • getFetchServerOutputSize

      public Integer getFetchServerOutputSize()
      Whether server output should be fetched after each query execution.
    • setFetchServerOutputSize

      public void setFetchServerOutputSize(Integer value)
      Whether server output should be fetched after each query execution.
    • isReturnIdentityOnUpdatableRecord

      public Boolean isReturnIdentityOnUpdatableRecord()
      Whether calls to store(), insert() and update() should return the identity column.
      Returns:
      possible object is Boolean
    • setReturnIdentityOnUpdatableRecord

      public void setReturnIdentityOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return the identity column.
      Parameters:
      value - allowed object is Boolean
    • isReturnDefaultOnUpdatableRecord

      public Boolean isReturnDefaultOnUpdatableRecord()
      Whether calls to store(), insert() and update() should return values for columns that are DataType.defaulted().
      Returns:
      possible object is Boolean
    • setReturnDefaultOnUpdatableRecord

      public void setReturnDefaultOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return values for columns that are DataType.defaulted().
      Parameters:
      value - allowed object is Boolean
    • isReturnComputedOnUpdatableRecord

      public Boolean isReturnComputedOnUpdatableRecord()
      Whether calls to store(), insert() and update() should return values for columns that are DataType.computed().
      Returns:
      possible object is Boolean
    • setReturnComputedOnUpdatableRecord

      public void setReturnComputedOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return values for columns that are DataType.computed().
      Parameters:
      value - allowed object is Boolean
    • isReturnAllOnUpdatableRecord

      public Boolean isReturnAllOnUpdatableRecord()
      Whether calls to store(), insert() and update() should return all columns, not just identity columns.

      Do note that only few databases support this feature. It is supported only in case the INSERT's or UPDATE's RETURNING clause is fully supported, also for non-IDENTITY columns.

      Returns:
      possible object is Boolean
    • setReturnAllOnUpdatableRecord

      public void setReturnAllOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return all columns, not just identity columns.

      Do note that only few databases support this feature. It is supported only in case the INSERT's or UPDATE's RETURNING clause is fully supported, also for non-IDENTITY columns.

      Parameters:
      value - allowed object is Boolean
    • isReturnRecordToPojo

      public Boolean isReturnRecordToPojo()
      Whether calls to store(), insert(), update(), and delete() that are called on an UpdatableRecord that is created from a POJO (e.g. in a DAO) should return all Record values to the POJO, including IDENTITY values, and if returnAllOnUpdatableRecord is active, also other values.
      Returns:
      possible object is Boolean
    • setReturnRecordToPojo

      public void setReturnRecordToPojo(Boolean value)
      Whether calls to store(), insert(), update(), and delete() that are called on an UpdatableRecord that is created from a POJO (e.g. in a DAO) should return all Record values to the POJO, including IDENTITY values, and if returnAllOnUpdatableRecord is active, also other values.
      Parameters:
      value - allowed object is Boolean
    • isMapJPAAnnotations

      public Boolean isMapJPAAnnotations()
      Whether JPA annotations should be considered by the DefaultRecordMapper.
      Returns:
      possible object is Boolean
    • setMapJPAAnnotations

      public void setMapJPAAnnotations(Boolean value)
      Whether JPA annotations should be considered by the DefaultRecordMapper.
      Parameters:
      value - allowed object is Boolean
    • isMapRecordComponentParameterNames

      public Boolean isMapRecordComponentParameterNames()
      Whether constructor parameter names obtained from the Record component names should be considered by the DefaultRecordMapper.
      Returns:
      possible object is Boolean
    • setMapRecordComponentParameterNames

      public void setMapRecordComponentParameterNames(Boolean value)
      Whether constructor parameter names obtained from the Record component names should be considered by the DefaultRecordMapper.
      Parameters:
      value - allowed object is Boolean
    • isMapConstructorPropertiesParameterNames

      public Boolean isMapConstructorPropertiesParameterNames()
      Whether constructor parameter names obtained from the ConstructorProperties annotation should be considered by the DefaultRecordMapper.
      Returns:
      possible object is Boolean
    • setMapConstructorPropertiesParameterNames

      public void setMapConstructorPropertiesParameterNames(Boolean value)
      Whether constructor parameter names obtained from the ConstructorProperties annotation should be considered by the DefaultRecordMapper.
      Parameters:
      value - allowed object is Boolean
    • isMapConstructorParameterNames

      public Boolean isMapConstructorParameterNames()
      Whether constructor parameter names obtained via reflection in Java 8+ should be considered by the DefaultRecordMapper. This flag has no effect in Java 6 or 7.
      Returns:
      possible object is Boolean
    • setMapConstructorParameterNames

      public void setMapConstructorParameterNames(Boolean value)
      Whether constructor parameter names obtained via reflection in Java 8+ should be considered by the DefaultRecordMapper. This flag has no effect in Java 6 or 7.
      Parameters:
      value - allowed object is Boolean
    • isMapConstructorParameterNamesInKotlin

      public Boolean isMapConstructorParameterNamesInKotlin()
      Whether constructor parameter names obtained via reflection in Kotlin should be considered by the DefaultRecordMapper. This flag has no effect in Java.
      Returns:
      possible object is Boolean
    • setMapConstructorParameterNamesInKotlin

      public void setMapConstructorParameterNamesInKotlin(Boolean value)
      Whether constructor parameter names obtained via reflection in Kotlin should be considered by the DefaultRecordMapper. This flag has no effect in Java.
      Parameters:
      value - allowed object is Boolean
    • getQueryPoolable

      public QueryPoolable getQueryPoolable()
      The default JDBC poolable property that should be applied to all jOOQ queries, for which no specific poolable flag was specified.
    • setQueryPoolable

      public void setQueryPoolable(QueryPoolable value)
      The default JDBC poolable property that should be applied to all jOOQ queries, for which no specific poolable flag was specified.
    • getQueryTimeout

      public Integer getQueryTimeout()
      The default JDBC queryTimeout property that should be applied to all jOOQ queries, for which no specific queryTimeout was specified.
    • setQueryTimeout

      public void setQueryTimeout(Integer value)
      The default JDBC queryTimeout property that should be applied to all jOOQ queries, for which no specific queryTimeout was specified.
    • getMaxRows

      public Integer getMaxRows()
      The default JDBC maxRows property that should be applied to all jOOQ queries, for which no specific maxRows value was specified.
    • setMaxRows

      public void setMaxRows(Integer value)
      The default JDBC maxRows property that should be applied to all jOOQ queries, for which no specific maxRows value was specified.
    • getFetchSize

      public Integer getFetchSize()
      The default JDBC fetchSize property that should be applied to all jOOQ queries, for which no specific fetchSize value was specified.
    • setFetchSize

      public void setFetchSize(Integer value)
      The default JDBC fetchSize property that should be applied to all jOOQ queries, for which no specific fetchSize value was specified.
    • getBatchSize

      public Integer getBatchSize()
      A property specifying a batch size that should be applied to all automatically created BatchedConnection instances.
    • setBatchSize

      public void setBatchSize(Integer value)
      A property specifying a batch size that should be applied to all automatically created BatchedConnection instances.
    • isDebugInfoOnStackTrace

      public Boolean isDebugInfoOnStackTrace()
      [#5570] Whether exception stack traces should be enhanced with additional debug information.
      Returns:
      possible object is Boolean
    • setDebugInfoOnStackTrace

      public void setDebugInfoOnStackTrace(Boolean value)
      [#5570] Whether exception stack traces should be enhanced with additional debug information.
      Parameters:
      value - allowed object is Boolean
    • isInListPadding

      public Boolean isInListPadding()
      [#5600] Whether IN lists in IN predicates should be padded to powers of inListPadBase (default 2).
      Returns:
      possible object is Boolean
    • setInListPadding

      public void setInListPadding(Boolean value)
      [#5600] Whether IN lists in IN predicates should be padded to powers of inListPadBase (default 2).
      Parameters:
      value - allowed object is Boolean
    • getInListPadBase

      public Integer getInListPadBase()
      [#7095] The base to use to calculate the powers of when applying in list padding.
    • setInListPadBase

      public void setInListPadBase(Integer value)
      [#7095] The base to use to calculate the powers of when applying in list padding.
    • getDelimiter

      public String getDelimiter()
      [#5826] The delimiter character to be used to delimit statements in batches.
    • setDelimiter

      public void setDelimiter(String value)
      [#5826] The delimiter character to be used to delimit statements in batches.
    • isEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly

      public Boolean isEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly()
      [#6462] Use only the primary key to emulate MySQL's INSERT .. ON DUPLICATE KEY UPDATE statement. In MySQL, the statement considers all unique keys for duplicates to apply an update rather than an insert. Earlier versions of jOOQ considered only the PRIMARY KEY. This flag can be turned on to maintain backwards compatibility.
      Returns:
      possible object is Boolean
    • setEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly

      public void setEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly(Boolean value)
      [#6462] Use only the primary key to emulate MySQL's INSERT .. ON DUPLICATE KEY UPDATE statement. In MySQL, the statement considers all unique keys for duplicates to apply an update rather than an insert. Earlier versions of jOOQ considered only the PRIMARY KEY. This flag can be turned on to maintain backwards compatibility.
      Parameters:
      value - allowed object is Boolean
    • getEmulateMultiset

      public NestedCollectionEmulation getEmulateMultiset()
      [#3884] How MULTISET support should be emulated.
    • setEmulateMultiset

      public void setEmulateMultiset(NestedCollectionEmulation value)
      [#3884] How MULTISET support should be emulated.
    • isEmulateComputedColumns

      public Boolean isEmulateComputedColumns()
      [#13418] Whether computed columns should be emulated in the client.

      This can be useful if a schema was generated using a dialect that supports computed columns, but it is deployed on an RDBMS that does not.

      Returns:
      possible object is Boolean
    • setEmulateComputedColumns

      public void setEmulateComputedColumns(Boolean value)
      [#13418] Whether computed columns should be emulated in the client.

      This can be useful if a schema was generated using a dialect that supports computed columns, but it is deployed on an RDBMS that does not.

      Parameters:
      value - allowed object is Boolean
    • getExecuteUpdateWithoutWhere

      public ExecuteWithoutWhere getExecuteUpdateWithoutWhere()
      [#6771] Specifies whether UPDATE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
    • setExecuteUpdateWithoutWhere

      public void setExecuteUpdateWithoutWhere(ExecuteWithoutWhere value)
      [#6771] Specifies whether UPDATE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
    • getExecuteDeleteWithoutWhere

      public ExecuteWithoutWhere getExecuteDeleteWithoutWhere()
      [#6771] Specifies whether DELETE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
    • setExecuteDeleteWithoutWhere

      public void setExecuteDeleteWithoutWhere(ExecuteWithoutWhere value)
      [#6771] Specifies whether DELETE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
    • getInterpreterDialect

      public SQLDialect getInterpreterDialect()
      [#7337] The dialect that should be used to interpret SQL DDL statements. SQLDialect.DEFAULT means that jOOQ interprets the SQL itself. Any other dialect (if supported) will be interpreted on an actual JDBC connection.
    • setInterpreterDialect

      public void setInterpreterDialect(SQLDialect value)
      [#7337] The dialect that should be used to interpret SQL DDL statements. SQLDialect.DEFAULT means that jOOQ interprets the SQL itself. Any other dialect (if supported) will be interpreted on an actual JDBC connection.
    • getInterpreterNameLookupCaseSensitivity

      public InterpreterNameLookupCaseSensitivity getInterpreterNameLookupCaseSensitivity()
      [#9633] The case sensitivity of identifiers used when interpreting SQL DDL statements.
    • setInterpreterNameLookupCaseSensitivity

      public void setInterpreterNameLookupCaseSensitivity(InterpreterNameLookupCaseSensitivity value)
      [#9633] The case sensitivity of identifiers used when interpreting SQL DDL statements.
    • getInterpreterLocale

      public Locale getInterpreterLocale()
      The Locale to be used with any interpreter locale dependent logic, defaulting to getLocale().
    • setInterpreterLocale

      public void setInterpreterLocale(Locale value)
      The Locale to be used with any interpreter locale dependent logic, defaulting to getLocale().
    • isInterpreterDelayForeignKeyDeclarations

      public Boolean isInterpreterDelayForeignKeyDeclarations()
      Using this flag, the interpreter will be able to delay the addition of foreign key declarations until the end of the interpretation run.
      Returns:
      possible object is Boolean
    • setInterpreterDelayForeignKeyDeclarations

      public void setInterpreterDelayForeignKeyDeclarations(Boolean value)
      Using this flag, the interpreter will be able to delay the addition of foreign key declarations until the end of the interpretation run.
      Parameters:
      value - allowed object is Boolean
    • isMetaIncludeSystemIndexes

      public Boolean isMetaIncludeSystemIndexes()
      The Meta implementation that is backed by DatabaseMetaData does not produce system generated indexes on constraints, by default.
      Returns:
      possible object is Boolean
    • setMetaIncludeSystemIndexes

      public void setMetaIncludeSystemIndexes(Boolean value)
      The Meta implementation that is backed by DatabaseMetaData does not produce system generated indexes on constraints, by default.
      Parameters:
      value - allowed object is Boolean
    • isMetaIncludeSystemSequences

      public Boolean isMetaIncludeSystemSequences()
      The Meta implementation that is backed by DatabaseMetaData does not produce system generated sequences, by default.
      Returns:
      possible object is Boolean
    • setMetaIncludeSystemSequences

      public void setMetaIncludeSystemSequences(Boolean value)
      The Meta implementation that is backed by DatabaseMetaData does not produce system generated sequences, by default.
      Parameters:
      value - allowed object is Boolean
    • getMigrationHistorySchema

      public MigrationSchema getMigrationHistorySchema()
      The database schema where the migration history is located.
    • setMigrationHistorySchema

      public void setMigrationHistorySchema(MigrationSchema value)
      The database schema where the migration history is located.
    • isMigrationHistorySchemaCreateSchemaIfNotExists

      public Boolean isMigrationHistorySchemaCreateSchemaIfNotExists()
      Whether getMigrationHistorySchema() should be created if it doesn't exist.
      Returns:
      possible object is Boolean
    • setMigrationHistorySchemaCreateSchemaIfNotExists

      public void setMigrationHistorySchemaCreateSchemaIfNotExists(Boolean value)
      Whether getMigrationHistorySchema() should be created if it doesn't exist.
      Parameters:
      value - allowed object is Boolean
    • getMigrationDefaultSchema

      public MigrationSchema getMigrationDefaultSchema()
      The default schema whose unqualified objects that are included in the migration.
    • setMigrationDefaultSchema

      public void setMigrationDefaultSchema(MigrationSchema value)
      The default schema whose unqualified objects that are included in the migration.
    • isMigrationSchemataCreateSchemaIfNotExists

      public Boolean isMigrationSchemataCreateSchemaIfNotExists()
      Whether getMigrationSchemata() should be created if they don't exist.
      Returns:
      possible object is Boolean
    • setMigrationSchemataCreateSchemaIfNotExists

      public void setMigrationSchemataCreateSchemaIfNotExists(Boolean value)
      Whether getMigrationSchemata() should be created if they don't exist.
      Parameters:
      value - allowed object is Boolean
    • isMigrationAllowsUndo

      public Boolean isMigrationAllowsUndo()
      Whether migrations are allowed to be executed in inverse order.

      This is a potentially destructive feature, which should not be turned on in production. It is useful mostly to quickly switch between branches in a development environment. This feature is available only in commercial distributions.

      Returns:
      possible object is Boolean
    • setMigrationAllowsUndo

      public void setMigrationAllowsUndo(Boolean value)
      Whether migrations are allowed to be executed in inverse order.

      This is a potentially destructive feature, which should not be turned on in production. It is useful mostly to quickly switch between branches in a development environment. This feature is available only in commercial distributions.

      Parameters:
      value - allowed object is Boolean
    • isMigrationRevertUntracked

      public Boolean isMigrationRevertUntracked()
      Whether migrations revert any untracked changes in the schemas that are being migrated.

      This is a potentially destructive feature, which should not be turned on in production. It is useful mostly to quickly revert any elements created in a development environment. This feature is available only in commercial distributions.

      Returns:
      possible object is Boolean
    • setMigrationRevertUntracked

      public void setMigrationRevertUntracked(Boolean value)
      Whether migrations revert any untracked changes in the schemas that are being migrated.

      This is a potentially destructive feature, which should not be turned on in production. It is useful mostly to quickly revert any elements created in a development environment. This feature is available only in commercial distributions.

      Parameters:
      value - allowed object is Boolean
    • isMigrationAutoBaseline

      public Boolean isMigrationAutoBaseline()
      Whether to automatically existing schemas that are not yet managed by jOOQ Migrations.
      Returns:
      possible object is Boolean
    • setMigrationAutoBaseline

      public void setMigrationAutoBaseline(Boolean value)
      Whether to automatically existing schemas that are not yet managed by jOOQ Migrations.
      Parameters:
      value - allowed object is Boolean
    • isMigrationAutoVerification

      public Boolean isMigrationAutoVerification()
      Whether a migration automatically runs a verification first.
      Returns:
      possible object is Boolean
    • setMigrationAutoVerification

      public void setMigrationAutoVerification(Boolean value)
      Whether a migration automatically runs a verification first.
      Parameters:
      value - allowed object is Boolean
    • isMigrationIgnoreDefaultTimestampPrecisionDiffs

      public Boolean isMigrationIgnoreDefaultTimestampPrecisionDiffs()
      Various migrateTo() methods (e.g. Meta.migrateTo(org.jooq.Meta)) ignore the difference between TIMESTAMP and TIMESTAMP(6), if 6 is the default precision for timestamps on the configured dialect.
      Returns:
      possible object is Boolean
    • setMigrationIgnoreDefaultTimestampPrecisionDiffs

      public void setMigrationIgnoreDefaultTimestampPrecisionDiffs(Boolean value)
      Various migrateTo() methods (e.g. Meta.migrateTo(org.jooq.Meta)) ignore the difference between TIMESTAMP and TIMESTAMP(6), if 6 is the default precision for timestamps on the configured dialect.
      Parameters:
      value - allowed object is Boolean
    • getLocale

      public Locale getLocale()
      The Locale to be used with any locale dependent logic if there is not a more specific locale available. More specific locales include e.g. getRenderLocale(), getParseLocale(), or getInterpreterLocale().
    • setLocale

      public void setLocale(Locale value)
      The Locale to be used with any locale dependent logic if there is not a more specific locale available. More specific locales include e.g. getRenderLocale(), getParseLocale(), or getInterpreterLocale().
    • getParseDialect

      public SQLDialect getParseDialect()
      [#7337] The input dialect that should be chosen to disambiguate ambiguous SQL syntax.
    • setParseDialect

      public void setParseDialect(SQLDialect value)
      [#7337] The input dialect that should be chosen to disambiguate ambiguous SQL syntax.
    • getParseLocale

      public Locale getParseLocale()
      The Locale to be used with any parser locale dependent logic, defaulting to getLocale().
    • setParseLocale

      public void setParseLocale(Locale value)
      The Locale to be used with any parser locale dependent logic, defaulting to getLocale().
    • getParseDateFormat

      public String getParseDateFormat()
      The date format to use when parsing functions whose behaviour depends on some session date format, such as NLS_DATE_FORMAT in Oracle
    • setParseDateFormat

      public void setParseDateFormat(String value)
      The date format to use when parsing functions whose behaviour depends on some session date format, such as NLS_DATE_FORMAT in Oracle
    • getParseTimestampFormat

      public String getParseTimestampFormat()
      The timestamp format to use when parsing functions whose behaviour depends on some session date format, such as NLS_TIMESTAMP_FORMAT in Oracle
    • setParseTimestampFormat

      public void setParseTimestampFormat(String value)
      The timestamp format to use when parsing functions whose behaviour depends on some session date format, such as NLS_TIMESTAMP_FORMAT in Oracle
    • getParseNamedParamPrefix

      public String getParseNamedParamPrefix()
      The prefix to use for named parameters in parsed SQL.

      Named parameter syntax defaults to :name (such as supported by Oracle, JPA, Spring), but vendor specific parameters may look differently. This flag can be used to determine the prefix to be used by named parameters, such as @ for SQL Server's @name or $ for PostgreSQL's $name when parsing SQL.

      "Named indexed" parameters can be obtained in the same way by specifingy ParamType#NAMED and not providing a name to parameters, resulting in :1 or @1 or $1, etc.

    • setParseNamedParamPrefix

      public void setParseNamedParamPrefix(String value)
      The prefix to use for named parameters in parsed SQL.

      Named parameter syntax defaults to :name (such as supported by Oracle, JPA, Spring), but vendor specific parameters may look differently. This flag can be used to determine the prefix to be used by named parameters, such as @ for SQL Server's @name or $ for PostgreSQL's $name when parsing SQL.

      "Named indexed" parameters can be obtained in the same way by specifingy ParamType#NAMED and not providing a name to parameters, resulting in :1 or @1 or $1, etc.

    • getParseNameCase

      public ParseNameCase getParseNameCase()
      [#7337] The default name case for parsed identifiers.
    • setParseNameCase

      public void setParseNameCase(ParseNameCase value)
      [#7337] The default name case for parsed identifiers.
    • getParseWithMetaLookups

      public ParseWithMetaLookups getParseWithMetaLookups()
      [#7163] Whether the parser should perform meta lookups in the Configuration's MetaProvider.
    • setParseWithMetaLookups

      public void setParseWithMetaLookups(ParseWithMetaLookups value)
      [#7163] Whether the parser should perform meta lookups in the Configuration's MetaProvider.
    • getParseAppendMissingTableReferences

      public Transformation getParseAppendMissingTableReferences()
      Transform the parsed SQL to append missing table references to the query's FROM or USING clause, if applicable.

      Teradata (and possibly others) allow for referencing tables that are not listed in the FROM clause, such as SELECT t.* FROM t WHERE t.i = u.i. This transformation is executed in the parser, to produce SELECT t.* FROM t, u WHERE t.i = u.i, instead. By default, it is active when the input dialect supports this syntax.

      This feature is available in the commercial distribution only.

    • setParseAppendMissingTableReferences

      public void setParseAppendMissingTableReferences(Transformation value)
      Transform the parsed SQL to append missing table references to the query's FROM or USING clause, if applicable.

      Teradata (and possibly others) allow for referencing tables that are not listed in the FROM clause, such as SELECT t.* FROM t WHERE t.i = u.i. This transformation is executed in the parser, to produce SELECT t.* FROM t, u WHERE t.i = u.i, instead. By default, it is active when the input dialect supports this syntax.

      This feature is available in the commercial distribution only.

    • isParseSetCommands

      public Boolean isParseSetCommands()
      [#9780] Whether commands of the type SET key = value should be parsed rather than ignored.
      Returns:
      possible object is Boolean
    • setParseSetCommands

      public void setParseSetCommands(Boolean value)
      [#9780] Whether commands of the type SET key = value should be parsed rather than ignored.
      Parameters:
      value - allowed object is Boolean
    • getParseUnsupportedSyntax

      public ParseUnsupportedSyntax getParseUnsupportedSyntax()
      [#5917] Whether the parser should accept unsupported (but known) syntax.
    • setParseUnsupportedSyntax

      public void setParseUnsupportedSyntax(ParseUnsupportedSyntax value)
      [#5917] Whether the parser should accept unsupported (but known) syntax.
    • getParseUnknownFunctions

      public ParseUnknownFunctions getParseUnknownFunctions()
      [#7344] Whether the parser should accept unknown functions.
    • setParseUnknownFunctions

      public void setParseUnknownFunctions(ParseUnknownFunctions value)
      [#7344] Whether the parser should accept unknown functions.
    • isParseIgnoreCommercialOnlyFeatures

      public Boolean isParseIgnoreCommercialOnlyFeatures()
      [#13109] Whether the parser of the jOOQ Open Source Edition should ignore commercial only features, rather than failing.
      Returns:
      possible object is Boolean
    • setParseIgnoreCommercialOnlyFeatures

      public void setParseIgnoreCommercialOnlyFeatures(Boolean value)
      [#13109] Whether the parser of the jOOQ Open Source Edition should ignore commercial only features, rather than failing.
      Parameters:
      value - allowed object is Boolean
    • isParseIgnoreComments

      public Boolean isParseIgnoreComments()
      [#8325] Whether the parser should ignore content between ignore comment tokens.
      Returns:
      possible object is Boolean
    • setParseIgnoreComments

      public void setParseIgnoreComments(Boolean value)
      [#8325] Whether the parser should ignore content between ignore comment tokens.
      Parameters:
      value - allowed object is Boolean
    • getParseIgnoreCommentStart

      public String getParseIgnoreCommentStart()
      [#8325] The ignore comment start token
    • setParseIgnoreCommentStart

      public void setParseIgnoreCommentStart(String value)
      [#8325] The ignore comment start token
    • getParseIgnoreCommentStop

      public String getParseIgnoreCommentStop()
      [#8325] The ignore comment stop token
    • setParseIgnoreCommentStop

      public void setParseIgnoreCommentStop(String value)
      [#8325] The ignore comment stop token
    • isParseRetainCommentsBetweenQueries

      public Boolean isParseRetainCommentsBetweenQueries()
      [#12538] Whether the parser should retain comments and whitespace between queries when parsing multiple queries through Parser.parse(String).

      jOOQ's query object model doesn't have a way to represent comments or other whitespace, and as such, the parser simply skips them by default. However, it may be desirable to retain comments before or in between top level queries, when parsing multiple such queries in a script. Comments inside of queries (including procedural statements) are still not supported.

      Returns:
      possible object is Boolean
    • setParseRetainCommentsBetweenQueries

      public void setParseRetainCommentsBetweenQueries(Boolean value)
      [#12538] Whether the parser should retain comments and whitespace between queries when parsing multiple queries through Parser.parse(String).

      jOOQ's query object model doesn't have a way to represent comments or other whitespace, and as such, the parser simply skips them by default. However, it may be desirable to retain comments before or in between top level queries, when parsing multiple such queries in a script. Comments inside of queries (including procedural statements) are still not supported.

      Parameters:
      value - allowed object is Boolean
    • isParseMetaDefaultExpressions

      public Boolean isParseMetaDefaultExpressions()
      [#8469] Whether to parse default expressions retrieved from DatabaseMetaData.
      Returns:
      possible object is Boolean
    • setParseMetaDefaultExpressions

      public void setParseMetaDefaultExpressions(Boolean value)
      [#8469] Whether to parse default expressions retrieved from DatabaseMetaData.
      Parameters:
      value - allowed object is Boolean
    • isParseMetaViewSources

      public Boolean isParseMetaViewSources()
      [#8469] Whether to parse view sources retrieved from DatabaseMetaData.
      Returns:
      possible object is Boolean
    • setParseMetaViewSources

      public void setParseMetaViewSources(Boolean value)
      [#8469] Whether to parse view sources retrieved from DatabaseMetaData.
      Parameters:
      value - allowed object is Boolean
    • getReadonlyTableRecordInsert

      public WriteIfReadonly getReadonlyTableRecordInsert()
      [#9864] The behaviour when trying to insert into readonly columns using TableRecord.insert().
    • setReadonlyTableRecordInsert

      public void setReadonlyTableRecordInsert(WriteIfReadonly value)
      [#9864] The behaviour when trying to insert into readonly columns using TableRecord.insert().
    • getReadonlyUpdatableRecordUpdate

      public WriteIfReadonly getReadonlyUpdatableRecordUpdate()
      [#9864] The behaviour when trying to update a readonly column using UpdatableRecord.update().
    • setReadonlyUpdatableRecordUpdate

      public void setReadonlyUpdatableRecordUpdate(WriteIfReadonly value)
      [#9864] The behaviour when trying to update a readonly column using UpdatableRecord.update().
    • getReadonlyInsert

      public WriteIfReadonly getReadonlyInsert()
      [#9864] The behaviour when trying to insert into readonly columns using Insert statements, or the insert clause of a Merge statement.
    • setReadonlyInsert

      public void setReadonlyInsert(WriteIfReadonly value)
      [#9864] The behaviour when trying to insert into readonly columns using Insert statements, or the insert clause of a Merge statement.
    • getReadonlyUpdate

      public WriteIfReadonly getReadonlyUpdate()
      [#9864] The behaviour when trying to update a readonly column using Update statements, or the update clause of a Merge statement.
    • setReadonlyUpdate

      public void setReadonlyUpdate(WriteIfReadonly value)
      [#9864] The behaviour when trying to update a readonly column using Update statements, or the update clause of a Merge statement.
    • isApplyWorkaroundFor7962

      public Boolean isApplyWorkaroundFor7962()
      [#7963] Apply workaround for ORA-04043 when inserting into Oracle tables with qualified, quoted identifiers, and fetching generated keys
      Returns:
      possible object is Boolean
    • setApplyWorkaroundFor7962

      public void setApplyWorkaroundFor7962(Boolean value)
      [#7963] Apply workaround for ORA-04043 when inserting into Oracle tables with qualified, quoted identifiers, and fetching generated keys
      Parameters:
      value - allowed object is Boolean
    • getWarnOnStaticTypeRegistryAccess

      public Warning getWarnOnStaticTypeRegistryAccess()
      [#15286] The warning level when the deprecated static type registry was accessed by legacy code.
    • setWarnOnStaticTypeRegistryAccess

      public void setWarnOnStaticTypeRegistryAccess(Warning value)
      [#15286] The warning level when the deprecated static type registry was accessed by legacy code.
    • getInterpreterSearchPath

      public List<InterpreterSearchSchema> getInterpreterSearchPath()
    • setInterpreterSearchPath

      public void setInterpreterSearchPath(List<InterpreterSearchSchema> interpreterSearchPath)
    • getMigrationSchemata

      public List<MigrationSchema> getMigrationSchemata()
    • setMigrationSchemata

      public void setMigrationSchemata(List<MigrationSchema> migrationSchemata)
    • getParseSearchPath

      public List<ParseSearchSchema> getParseSearchPath()
    • setParseSearchPath

      public void setParseSearchPath(List<ParseSearchSchema> parseSearchPath)
    • withForceIntegerTypesOnZeroScaleDecimals

      public Settings withForceIntegerTypesOnZeroScaleDecimals(Boolean value)
      Historically, zero-scale decimal types are generated as their most appropriate, corresponding integer type (e.g. NUMBER(2, 0) and less: Byte). The same behaviour is replicated in the Meta API. This flag allows for turning off this feature.
    • withRenderCatalog

      public Settings withRenderCatalog(Boolean value)
      Whether any catalog name should be rendered at all.

      Use this for single-catalog environments, or when all objects are made available using synonyms

    • withRenderSchema

      public Settings withRenderSchema(Boolean value)
      Whether any schema name should be rendered at all.

      Setting this to false also implicitly sets "renderCatalog" to false.

      Use this for single-schema environments, or when all objects are made available using synonyms

    • withRenderTable

      public Settings withRenderTable(RenderTable value)
      Whether any table name qualification should be rendered at all on columns.

      Setting when tables aren't rendered, then implicitly, schemas and catalogs aren't rendered either.

      The following values are available:

      • RenderTable.ALWAYS: The default, which should always be preferred. Columns are always qualified with their tables, where possible.
      • RenderTable.WHEN_MULTIPLE_TABLES: The simplest option to reduce generated query verbosity, avoiding table qualification only in queries with a single table in the FROM clause.
      • RenderTable.WHEN_AMBIGUOUS_COLUMNS: A much more expensive to compute option that checks the FROM clause for ambiguous column names, in case of which columns are qualified.
      • RenderTable.NEVER: Always turn off table qualification.

      Use this when verbosity of rendered SQL is a problem.

    • withRenderMapping

      public Settings withRenderMapping(RenderMapping value)
      Configure render mapping for runtime schema / table rewriting in generated SQL.
    • withRenderQuotedNames

      public Settings withRenderQuotedNames(RenderQuotedNames value)
      Whether rendered schema, table, column names, etc should be quoted.

      This only affects names created through DSL.name(String) methods (including those that are implicitly created through this method), not DSL.quotedName(String) or DSL.unquotedName(String), whose behaviour cannot be overridden.

      This setting does not affect any plain SQL usage.

    • withRenderNameCase

      public Settings withRenderNameCase(RenderNameCase value)
      Whether the case of Name references should be modified in any way.

      Names are modified irrespective of the getRenderQuotedNames() setting.

      This setting does not affect any plain SQL usage.

    • withRenderNameStyle

      @Deprecated public Settings withRenderNameStyle(RenderNameStyle value)
      Deprecated.
      - 3.12.0 - [#5909] - Use RenderQuotedNames and RenderNameCase instead.
      Whether rendered schema, table, column names, etc should be quoted in rendered SQL, or transformed in any other way.

      This is set to "QUOTED" by default for backwards-compatibility.

    • withRenderNamedParamPrefix

      public Settings withRenderNamedParamPrefix(String value)
      The prefix to use for named parameters in generated SQL.

      Named parameter syntax defaults to :name (such as supported by Oracle, JPA, Spring), but vendor specific parameters may look differently. This flag can be used to determine the prefix to be used by named parameters, such as @ for SQL Server's @name or $ for PostgreSQL's $name, when generating SQL.

      "Named indexed" parameters can be obtained in the same way by specifingy ParamType#NAMED and not providing a name to parameters, resulting in :1 or @1 or $1, etc.

    • withRenderKeywordCase

      public Settings withRenderKeywordCase(RenderKeywordCase value)
      Whether the case of Keyword references should be modified in any way.
    • withRenderKeywordStyle

      @Deprecated public Settings withRenderKeywordStyle(RenderKeywordStyle value)
      Deprecated.
      - 3.12.0 - [#5909] - Use RenderKeywordCase instead.
      Whether the case of Keyword references should be modified in any way.

    • withRenderLocale

      public Settings withRenderLocale(Locale value)
      The Locale to be used with any render locale dependent logic (as e.g. transforming names to lower / uppper case), defaulting to getLocale().
    • withRenderFormatted

      public Settings withRenderFormatted(Boolean value)
      Whether rendered SQL should be pretty-printed.
    • withRenderFormatting

      public Settings withRenderFormatting(RenderFormatting value)
      All sorts of formatting flags / settings.
    • withRenderOptionalAssociativityParentheses

      public Settings withRenderOptionalAssociativityParentheses(RenderOptionalKeyword value)
      Whether to render optional parentheses to make associativity explicit, e.g. ((a + b) + c) instead of (a + b + c).
    • withRenderOptionalAsKeywordForTableAliases

      public Settings withRenderOptionalAsKeywordForTableAliases(RenderOptionalKeyword value)
      Whether to render the optional AS keyword in table aliases, if it is optional in the output dialect. This is ignored if the keyword is not supported (e.g. in Oracle)
    • withRenderOptionalAsKeywordForFieldAliases

      public Settings withRenderOptionalAsKeywordForFieldAliases(RenderOptionalKeyword value)
      Whether to render the optional AS keyword in table aliases, if it is optional in the output dialect.
    • withRenderOptionalInnerKeyword

      public Settings withRenderOptionalInnerKeyword(RenderOptionalKeyword value)
      Whether to render the optional INNER keyword in INNER JOIN, if it is optional in the output dialect.
    • withRenderOptionalOuterKeyword

      public Settings withRenderOptionalOuterKeyword(RenderOptionalKeyword value)
      Whether to render the optional OUTER keyword in OUTER JOIN, if it is optional in the output dialect.
    • withRenderImplicitWindowRange

      public Settings withRenderImplicitWindowRange(RenderImplicitWindowRange value)
      Whether to render an explicit window RANGE clause when an implicit clause is applied.
    • withRenderScalarSubqueriesForStoredFunctions

      public Settings withRenderScalarSubqueriesForStoredFunctions(Boolean value)
      Whether stored function calls should be wrapped in scalar subqueries.

      Oracle 11g (and potentially, other databases too) implements scalar subquery caching. With this flag set to true, users can automatically profit from this feature in all SQL statements.

    • withRenderImplicitJoinType

      public Settings withRenderImplicitJoinType(RenderImplicitJoinType value)
      The join type to be generated by implicit joins for to-one paths in Select queries.

      The DEFAULT is dependent on the nullability of the foreign key (LEFT_JOIN for nullable foreign keys and INNER_JOIN for non-nullable foreign keys). In DML statements, it is always SCALAR_SUBQUERY, unless DML joins are supported.

    • withRenderImplicitJoinToManyType

      public Settings withRenderImplicitJoinToManyType(RenderImplicitJoinType value)
      The join type to be generated by implicit joins for to-many paths in Select queries.

      The DEFAULT is SCALAR_SUBQUERY if the join path is implicit only, i.e. absent from the FROM clause, to prevent accidental cartesian products, or LEFT_JOIN if declared explicitly in the FROM clause. In DML statements, it is always SCALAR_SUBQUERY, unless DML joins are supported.

    • withRenderDefaultNullability

      public Settings withRenderDefaultNullability(RenderDefaultNullability value)
      Whether the Nullability.DEFAULT nullablity should be rendered in generated DDL, and how it should be rendered.
    • withRenderCoalesceToEmptyStringInConcat

      public Settings withRenderCoalesceToEmptyStringInConcat(Boolean value)
      Whether stored function calls should be wrapped in scalar subqueries.

      Oracle 11g (and potentially, other databases too) implements scalar subquery caching. With this flag set to true, users can automatically profit from this feature in all SQL statements.

      This feature is available in the commercial distribution only.

    • withRenderOrderByRownumberForEmulatedPagination

      public Settings withRenderOrderByRownumberForEmulatedPagination(Boolean value)
      Whether an additional ORDER BY rn clause should be rendered on emulated paginated queries.

      Older databases did not support OFFSET .. FETCH pagination, so jOOQ emulates it using derived tables and ROWNUM (Oracle 11g and older) or ROW_NUMBER() (e.g. DB2, SQL Server, etc.) filtering. While these subqueries are ordered, the ordering is not guaranteed to be stable in the outer most queries. It may be stable (and e.g. in Oracle, it mostly is, if queries are not parallel, or joined to other queries, etc.), so the excess ORDER BY clause may add some additional performance overhead. This setting forces jOOQ to not generate the additional ORDER BY clause.

      For details, see https://github.com/jOOQ/jOOQ/issues/7609.

    • withRenderOutputForSQLServerReturningClause

      public Settings withRenderOutputForSQLServerReturningClause(Boolean value)
      Whether the jOOQ RETURNING clause should map to SQL Server's OUTPUT clause.

      SQL Server supports an OUTPUT clause in most DML statements, whose behaviour is almost identical to RETURNING in Firebird, Oracle, PostgreSQL. Users who want to prevent jOOQ from rendering this OUTPUT clause can deactivate this flag to revert to jOOQ calling java.sql.Statement#getGeneratedKeys() instead, which is only supported for single row inserts.

      This OUTPUT clause does not support fetching trigger generated values. In order to fetch trigger generated values, fetchTriggerValuesAfterReturning needs to be enabled as well.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

    • withRenderGroupConcatMaxLenSessionVariable

      public Settings withRenderGroupConcatMaxLenSessionVariable(Boolean value)
      Whether the jOOQ GROUP_CONCAT function should be overflow-protected by setting the @@group_concat_max_len session variable in MySQL style database systems.

      MySQL truncates GROUP_CONCAT results after a certain length, which may be way too small for jOOQ's usage, especially when using the MULTISET emulation. By default, jOOQ sets a session variable to the highest possible value prior to executing a query containing GROUP_CONCAT. This flag can be used to opt out of this.

      For details, see https://github.com/jOOQ/jOOQ/issues/12092.

    • withRenderParenthesisAroundSetOperationQueries

      public Settings withRenderParenthesisAroundSetOperationQueries(Boolean value)
      Whether queries combined with set operators (e.g. UNION and UNION ALL) should always be surrounded by a parenthesis pair.

      By default (i.e. when this setting is set to false jOOQ will only render parenthesis pairs around queries combined with set operators when required. This is for example the case when set operators are nested, when non-associative operators like EXCEPT are used, or when the queries are rendered as derived tables.

      When this setting is set to true the queries combined with set operators will always be surrounded by a parenthesis pair.

      For details, see https://github.com/jOOQ/jOOQ/issues/3676 and https://github.com/jOOQ/jOOQ/issues/9751.

    • withRenderVariablesInDerivedTablesForEmulations

      public Settings withRenderVariablesInDerivedTablesForEmulations(Boolean value)
      Whether emulations that require repeating expressions should render variables for those expressions in derived tables.

      For details, see https://github.com/jOOQ/jOOQ/issues/14065.

    • withRenderRowConditionForSeekClause

      public Settings withRenderRowConditionForSeekClause(Boolean value)
      Whether a (a, b) invalid input: '<' (:a, :b) row predicate should be rendered for the SEEK clause.

      Some RDBMS may support (a, b) invalid input: '<' (:a, :b) row predicate syntax, which is very convenient for SEEK clause implementations, but fail to optimise this predicate as could be expected. This flag allows for expanding the predicate to the much more verbose, but equivalent (a invalid input: '<' :a) OR (a = :a AND b invalid input: '<' :b). Dialects without native support for row predicates aren't affected by this flag.

    • withRenderRedundantConditionForSeekClause

      public Settings withRenderRedundantConditionForSeekClause(Boolean value)
      Whether a redundant (a invalid input: '<'= :a) predicate should be rendered for a (a, b) invalid input: '<' (:a, :b) predicate for the SEEK clause.

      Some RDBMS may not be able to properly optimise (a, b) invalid input: '<' ('a', 'b') or (a invalid input: '<' 'a') OR (a = 'a' AND b invalid input: '<' 'b'), and choose an appropriate index. By adding an additional redundant predicate, jOOQ may help the optimiser, e.g. (a invalid input: '<'= :a) AND (a, b) invalid input: '<' ('a', 'b') or (a invalid input: '<'= :a) AND ((a invalid input: '<' 'a') OR (a = 'a' AND b invalid input: '<' 'b'))

    • withRenderPlainSQLTemplatesAsRaw

      public Settings withRenderPlainSQLTemplatesAsRaw(Boolean value)
      Whether plain SQL templates (SQL) are rendered as raw string content.
    • withRenderDollarQuotedStringToken

      public Settings withRenderDollarQuotedStringToken(String value)
      The token to place between the $$ signs of a PostgreSQL dollar quoted string generated by jOOQ.
    • withNamePathSeparator

      public Settings withNamePathSeparator(String value)
      The character(s) to be used as a separator in paths encoded in a
      invalid @link
      Name

      A few hierarchical mapping features work with paths encoded in names (specifically field aliases), such as the reflective mapping of nested values when aliasing fields as:

      
       SELECT 
         a.first_name AS "book.author.firstName"
         a.last_name AS "book.author.lastName"
       FROM ...
       

      Not all dialects support "." in identifiers. This setting allows for specifying an alternative String to use as separator, e.g. "__".

    • withBindOffsetDateTimeType

      public Settings withBindOffsetDateTimeType(Boolean value)
      Whether the java.time (JSR 310) type OffsetDateTime should be bound natively to JDBC.

      Historically, jOOQ encoded the java.time types as strings to offer better compatibility with older JDBC drivers. By now, most drivers should support the java.time types. Using them may produce better performance both on the server and on the client side.

      This flag allows for reverting to pre-jOOQ 3.14 behaviour, where the default is to bind these types natively.

      For details, see https://github.com/jOOQ/jOOQ/issues/9902.

    • withBindOffsetTimeType

      public Settings withBindOffsetTimeType(Boolean value)
      Whether the java.time (JSR 310) type OffsetTime should be bound natively to JDBC.

      Historically, jOOQ encoded the java.time types as strings to offer better compatibility with older JDBC drivers. By now, most drivers should support the java.time types. Using them may produce better performance both on the server and on the client side.

      This flag allows for reverting to pre-jOOQ 3.14 behaviour, where the default is to bind these types natively.

      For details, see https://github.com/jOOQ/jOOQ/issues/9902.

    • withFetchTriggerValuesAfterSQLServerOutput

      public Settings withFetchTriggerValuesAfterSQLServerOutput(Boolean value)
      Deprecated.
      - 3.18.0 - [#13912] [#15316] - Use fetchTriggerValuesAfterReturning instead.
      Fetch trigger values after SQL Server OUTPUT clause.

      SQL Server OUTPUT statements do not support fetching trigger generated values. This is a limitation of the renderOutputForSQLServerReturningClause. An additional MERGE statement can run a second query if (and only if) the primary key has been included in the OUTPUT clause.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

    • withFetchTriggerValuesAfterReturning

      public Settings withFetchTriggerValuesAfterReturning(FetchTriggerValuesAfterReturning value)
      Fetch trigger values after a RETURNING clause in dialects that don't have native support for this.

      SQL Server OUTPUT clauses do not support fetching trigger generated values. Neither do SQLite RETURNING clauses. An additional MERGE statement can run a second query if (and only if) the primary key has been included in the OUTPUT clause.

      Trigger meta data is only available in jOOQ's commercial editions. If setting this flag to WHEN_NEEDED in the jOOQ Open Source Edition, jOOQ will assume triggers are present.

      For details, see https://github.com/jOOQ/jOOQ/issues/4498.

    • withFetchIntermediateResult

      public Settings withFetchIntermediateResult(FetchIntermediateResult value)
      Whether to fetch data into intermediate Result instances.

      By default, a ResultQuery produces no intermediate Result instances if they are not explicitly requested by the caller, e.g. by calling ResultQuery.fetch(), or in the presence of ExecuteListener instances, which may require access to ExecuteContext.result(). This default behaviour helps avoid unnecessary allocations of possibly large data structures.

      Using this flag, fetching of intermediate results can be turned off even when execute listeners are present, or turned on even if they're absent.

    • withDiagnosticsDuplicateStatements

      public Settings withDiagnosticsDuplicateStatements(Boolean value)
      Whether to run the DiagnosticsListener.duplicateStatements(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

    • withDiagnosticsDuplicateStatementsUsingTransformPatterns

      public Settings withDiagnosticsDuplicateStatementsUsingTransformPatterns(Boolean value)
      Whether to run the DiagnosticsListener.duplicateStatements(org.jooq.DiagnosticsContext) diagnostic with the transformPatterns feature activated.

      When transforming patterns, many more complex, duplicate SQL statements can be recognised than if simply parsing and re-rendering the statement. This flag turns on all transformation patterns, independently of their individual settings.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withDiagnosticsMissingWasNullCall

      public Settings withDiagnosticsMissingWasNullCall(Boolean value)
      Whether to run the DiagnosticsListener.missingWasNullCall(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

    • withDiagnosticsRepeatedStatements

      public Settings withDiagnosticsRepeatedStatements(Boolean value)
      Whether to run the DiagnosticsListener.repeatedStatements(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

    • withDiagnosticsConsecutiveAggregation

      public Settings withDiagnosticsConsecutiveAggregation(Boolean value)
      Whether to run the DiagnosticsListener.consecutiveAggregation(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withDiagnosticsConcatenationInPredicate

      public Settings withDiagnosticsConcatenationInPredicate(Boolean value)
      Whether to run the DiagnosticsListener.concatenationInPredicate(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withDiagnosticsPossiblyWrongExpression

      public Settings withDiagnosticsPossiblyWrongExpression(Boolean value)
      Whether to run the DiagnosticsListener.possiblyWrongExpression(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withDiagnosticsTooManyColumnsFetched

      public Settings withDiagnosticsTooManyColumnsFetched(Boolean value)
      Whether to run the DiagnosticsListener.tooManyColumnsFetched(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

    • withDiagnosticsTooManyRowsFetched

      public Settings withDiagnosticsTooManyRowsFetched(Boolean value)
      Whether to run the DiagnosticsListener.tooManyRowsFetched(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

    • withDiagnosticsUnnecessaryWasNullCall

      public Settings withDiagnosticsUnnecessaryWasNullCall(Boolean value)
      Whether to run the DiagnosticsListener.unnecessaryWasNullCall(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

    • withDiagnosticsPatterns

      public Settings withDiagnosticsPatterns(Boolean value)
      Whether to run the various pattern transformation diagnostics.

      transformPatterns allows for applying numerous pattern transformations, which can be turned on separately when running diagnostics. This flag overrides the transformPatterns flag in the diagnostics context. Individual pattern flags still allow to enable / disable the pattern for diagnostics.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withDiagnosticsTrivialCondition

      public Settings withDiagnosticsTrivialCondition(Boolean value)
      Whether to run the DiagnosticsListener.trivialCondition(org.jooq.DiagnosticsContext) diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withDiagnosticsNullCondition

      public Settings withDiagnosticsNullCondition(Boolean value)
      Whether to run the
      invalid @link
      org.jooq.DiagnosticsListener#nullConditoin(org.jooq.DiagnosticsContext)
      diagnostic.

      Diagnostics are turned off if no Configuration.diagnosticsListenerProviders() are configured. Once configured, this diagnostic is turned on by default.

      This feature is available in the commercial distribution only.

    • withTransformPatterns

      public Settings withTransformPatterns(Boolean value)
      Transform various syntax patterns to better versions, if possible.

      This flag enables the pattern transformation feature, which consists of several sub-flags that are all prefixed with "transformPatterns", e.g. transformPatternsTrim. While the sub-flags default to being enabled, and can be disabled on an individual basis, the global feature itself is disabled by default.

      This feature is available in the commercial distribution only.

    • withTransformPatternsLogging

      public Settings withTransformPatternsLogging(Boolean value)
      Activate debug logging of the transformPatterns feature.
    • withTransformPatternsUnnecessaryDistinct

      public Settings withTransformPatternsUnnecessaryDistinct(Boolean value)
      Transform SELECT DISTINCT a, b FROM t GROUP BY a, b to SELECT a, b FROM t GROUP BY a, b.

      The GROUP BY clause already removes duplicates, so if the DISTINCT clause contains at least all the columns from GROUP BY then it can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnnecessaryScalarSubquery

      public Settings withTransformPatternsUnnecessaryScalarSubquery(Boolean value)
      Transform SELECT (SELECT 1) to SELECT 1.

      Scalar subqueries that don't have any content other than a SELECT clause are unnecessary and can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnnecessaryInnerJoin

      public Settings withTransformPatternsUnnecessaryInnerJoin(Boolean value)
      Transform SELECT * FROM t INNER JOIN u ON TRUE to SELECT * FROM t CROSS JOIN u.

      Some INNER JOIN expressions can be proven to be unnecessary.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnnecessaryGroupByExpressions

      public Settings withTransformPatternsUnnecessaryGroupByExpressions(Boolean value)
      Transform SELECT a, b FROM t GROUP BY a, a, b to SELECT a, b FROM t GROUP BY a, b.

      Duplicate GROUP BY expressions can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnnecessaryOrderByExpressions

      public Settings withTransformPatternsUnnecessaryOrderByExpressions(Boolean value)
      Transform SELECT a, b FROM t ORDER BY a, a, b to SELECT a, b FROM t ORDER BY a, b.

      Duplicate ORDER BY expressions can be removed.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnnecessaryExistsSubqueryClauses

      public Settings withTransformPatternsUnnecessaryExistsSubqueryClauses(Boolean value)
      Transform [ NOT ] EXISTS (SELECT DISTINCT a, b FROM t ORDER BY c LIMIT d) to [ NOT ] EXISTS (SELECT 1 FROM t).

      In EXISTS subqueries, quite a few SELECT clauses are meaningless, and can thus be removed. These include:

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsCountConstant

      public Settings withTransformPatternsCountConstant(Boolean value)
      Transform COUNT(1) or any other COUNT(const) to COUNT(*).

      There is no benefit to counting a constant expression. In fact, in some RDBMS, it might even be slightly slower, at least in benchmarks.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsTrim

      public Settings withTransformPatternsTrim(Boolean value)
      Transform LTRIM(RTRIM(x)) or RTRIM(LTRIM(x)) to TRIM(x).

      Historically, a few dialects did not implement TRIM(x) or TRIM(BOTH FROM x), so users worked around this by wrapping LTRIM() and RTRIM() with each other. Maintaining this is usually undesirable, so this transformation helps remove the unwanted wrapping.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNotAnd

      public Settings withTransformPatternsNotAnd(Boolean value)
      Transform NOT(p AND q) to NOT(p) OR NOT(q).

      This transformation normalises a predicate using De Morgan's rules.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNotOr

      public Settings withTransformPatternsNotOr(Boolean value)
      Transform NOT(p OR q) to NOT(p) AND NOT(q).

      This transformation normalises a predicate using De Morgan's rules.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNotNot

      public Settings withTransformPatternsNotNot(Boolean value)
      Transform NOT(NOT(x)) to x.

      This transformation removes a redundant logic negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNotComparison

      public Settings withTransformPatternsNotComparison(Boolean value)
      Transform NOT (a != b) to a = b, and similar comparisons.

      This transformation removes a redundant logical negation from the DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNotNotDistinct

      public Settings withTransformPatternsNotNotDistinct(Boolean value)
      Transform NOT (a IS NOT DISTINCT FROM b) to a IS DISTINCT FROM b.

      This transformation removes a redundant logical negation from the DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsDistinctFromNull

      public Settings withTransformPatternsDistinctFromNull(Boolean value)
      Transform a IS [ NOT ] DISTINCT FROM NULL to a IS [ NOT ] NULL.

      This simplifies the much more verbose DISTINCT predicate.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNormaliseAssociativeOps

      public Settings withTransformPatternsNormaliseAssociativeOps(Boolean value)
      Transform (a + b) + (c + d) to ((a + b) + c) + d.

      This transformation turns trees into lists, which greatly simplifies other tree traversal transformations. Some of those other transformations currently rely on this flag to be active.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNormaliseInListSingleElementToComparison

      public Settings withTransformPatternsNormaliseInListSingleElementToComparison(Boolean value)
      Transform x IN (a) to x = a and x NOT IN (a) to x != a.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNormaliseFieldCompareValue

      public Settings withTransformPatternsNormaliseFieldCompareValue(Boolean value)
      Transform 1 = a to a = 1.

      This transformation inverses

      invalid @link
      TableField
      [op]
      invalid @link
      org.jooq.impl.QOM.Val
      comparisons, if they're not in that order.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNormaliseCoalesceToNvl

      public Settings withTransformPatternsNormaliseCoalesceToNvl(Boolean value)
      Transform 2 argument COALESCE(a, b) to NVL(a, b).

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsOrEqToIn

      public Settings withTransformPatternsOrEqToIn(Boolean value)
      Transform x = c1 OR x = c2 to x IN (c1, c2).

      This transformation simplifies verbose OR predicates into simpler IN predicates.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsAndNeToNotIn

      public Settings withTransformPatternsAndNeToNotIn(Boolean value)
      Transform x != c1 AND x != c2 to x NOT IN (c1, c2).

      This transformation simplifies verbose AND predicates into simpler NOT IN predicates.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsMergeOrComparison

      public Settings withTransformPatternsMergeOrComparison(Boolean value)
      Transform x = a OR x > a to x >= a.

      This transformation merges multiple OR connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsMergeAndComparison

      public Settings withTransformPatternsMergeAndComparison(Boolean value)
      Transform x >= a AND x invalid input: '<'= a to x = a.

      This transformation merges multiple AND connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsMergeInLists

      public Settings withTransformPatternsMergeInLists(Boolean value)
      Transform x IN (a, b, c) AND x IN (b, c, d) to x IN (b, c).

      This transformation merges multiple OR connected comparisons to a single comparison using a simpler operator.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsMergeRangePredicates

      public Settings withTransformPatternsMergeRangePredicates(Boolean value)
      Transform x >= a AND x invalid input: '<'= b to x BETWEEN a AND b.

      This transformation merges multiple AND connected range predicates to a single comparison using BETWEEN.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsMergeBetweenSymmetricPredicates

      public Settings withTransformPatternsMergeBetweenSymmetricPredicates(Boolean value)
      Transform x BETWEEN a AND b OR x BETWEEN b AND a to x BETWEEN SYMMETRIC a AND b.

      This transformation merges multiple OR connected BETWEEN predicates to a single comparison using BETWEEN SYMMETRIC.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsCaseSearchedToCaseSimple

      public Settings withTransformPatternsCaseSearchedToCaseSimple(Boolean value)
      Transform a searched CASE WHEN x = .. WHEN x = .. to a simple CASE x WHEN … WHEN … expression.

      When a searched CASE expression always compares the same column to a value, then it can be simplified, possibly unlocking further transformations that are available only to the simple CASE expression.

      This feature is available in the commercial distribution only.

    • withTransformPatternsCaseElseNull

      public Settings withTransformPatternsCaseElseNull(Boolean value)
      Transform CASE … ELSE NULL removing the ELSE clause.

      CASE WHEN x THEN y ELSE NULL END is equivalent to CASE WHEN x THEN y END.

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnreachableCaseClauses

      public Settings withTransformPatternsUnreachableCaseClauses(Boolean value)
      Transform CASE by removing unreachable clauses.

      Case clauses can be proven to be unreachable, and thus removed:

      • CASE WHEN p THEN 1 WHEN TRUE THEN 2 WHEN q … ELSE … END is equivalent to CASE WHEN p THEN 1 ELSE 2 END
      • CASE WHEN p THEN 1 WHEN FALSE THEN 2 WHEN q .. ELSE .. END is equivalent to CASE WHEN p THEN 1 WHEN q … ELSE … END

      This feature is available in the commercial distribution only.

    • withTransformPatternsUnreachableDecodeClauses

      public Settings withTransformPatternsUnreachableDecodeClauses(Boolean value)
      Transform DECODE by removing unreachable clauses.

      DECODE clauses can be proven to be unreachable, and thus removed:

      • DECODE(a, b, 1, c, 2, b, 3) is equivalent to DECODE(a, b, 1, c, 2)
      • DECODE(a, b, 1, c, 2, b, 3, 4) is equivalent to DECODE(a, b, 1, c, 2, 4)

      This feature is available in the commercial distribution only.

    • withTransformPatternsCaseDistinctToDecode

      public Settings withTransformPatternsCaseDistinctToDecode(Boolean value)
      Transform CASE WHEN a IS NOT DISTINCT FROM b … to an equivalent DECODE function.

      When all WHEN clauses of a CASE expression use the DISTINCT predicate, then the CASE expression can be transformed into a DECODE function call:

      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 END is equivalent to DECODE(a, b, 1)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 ELSE 2 END is equivalent to DECODE(a, b, 1, 2)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 WHEN a IS NOT DISTINCT FROM c THEN 2 END is equivalent to DECODE(a, b, 1, c, 2)
      • CASE WHEN a IS NOT DISTINCT FROM b THEN 1 WHEN a IS NOT DISTINCT FROM c THEN 2 ELSE 3 END is equivalent to DECODE(a, b, 1, c, 2, 3)

      This feature is available in the commercial distribution only.

    • withTransformPatternsCaseMergeWhenWhen

      public Settings withTransformPatternsCaseMergeWhenWhen(Boolean value)
      Transform CASE WHEN a THEN x WHEN b THEN x END to CASE WHEN a OR b THEN x END.

      Two consecutive WHEN clauses can be merged, if their respective THEN clause is identical.

      This feature is available in the commercial distribution only.

    • withTransformPatternsCaseMergeWhenElse

      public Settings withTransformPatternsCaseMergeWhenElse(Boolean value)
      Transform CASE WHEN a THEN x WHEN b THEN y ELSE y END to CASE WHEN a THEN x ELSE y END.

      The ultimate WHEN clause can be merged with the ELSE, if their respective result is identical. If the WHEN clause is the only WHEN clause, then the entire CASE expression can be replaced by the ELSE clause content.

      This feature is available in the commercial distribution only.

    • withTransformPatternsCaseToCaseAbbreviation

      public Settings withTransformPatternsCaseToCaseAbbreviation(Boolean value)
      Transform CASE expressions to their respective abbreviations.

      Some CASE expressions have a shorter abbreviated form, such as COALESCE() or NULLIF().

      This feature is available in the commercial distribution only.

    • withTransformPatternsSimplifyCaseAbbreviation

      public Settings withTransformPatternsSimplifyCaseAbbreviation(Boolean value)
      Transform complex predicates into simpler CASE abbreviations.

      Some predicates can be simplified into case abbreviations, such as, for example

      • a IS NULL OR COALESCE(a = b, FALSE) to NULLIF(a, b) IS NULL
      • a IS NOT NULL AND COALESCE(a != b, TRUE) to NULLIF(a, b) IS NOT NULL

      This feature is available in the commercial distribution only.

    • withTransformPatternsFlattenCaseAbbreviation

      public Settings withTransformPatternsFlattenCaseAbbreviation(Boolean value)
      Flatten nested CASE abbreviations such as NVL or CASE.

      Nested CASE abbreviations can be flattened, as such:

      • NVL(NVL(a, b), c) to COALESCE(a, b, c)
      • COALESCE(a, ..., COALESCE(b, ..., c), ..., d) to COALESCE(a, …, b, …, c, ..., d)

      This feature is available in the commercial distribution only.

    • withTransformPatternsFlattenDecode

      public Settings withTransformPatternsFlattenDecode(Boolean value)
      Flatten nested DECODE functions.

      Nested DECODE functions can be flattened, as such:

      • DECODE(a, b, c, DECODE(a, d, e)) to DECODE(a, b, c, d, e)

      This feature is available in the commercial distribution only.

    • withTransformPatternsFlattenCase

      public Settings withTransformPatternsFlattenCase(Boolean value)
      Transform CASE … ELSE CASE … by flattening the nested CASE.

      CASE WHEN a THEN b ELSE CASE WHEN c THEN d END END is equivalent to CASE WHEN a THEN b WHEN c THEN d END.

      This feature is available in the commercial distribution only.

    • withTransformPatternsTrivialCaseAbbreviation

      public Settings withTransformPatternsTrivialCaseAbbreviation(Boolean value)
      Transform trivial case abbreviations like NVL(NULL, a) to a.

      This transformation removes any trivial case abbreviations, such as NVL(), COALESCE(), NULLIF(), etc.

      This feature is available in the commercial distribution only.

    • withTransformPatternsTrivialPredicates

      public Settings withTransformPatternsTrivialPredicates(Boolean value)
      Transform trivial predicates like 1 = 1 to TRUE.

      This transformation removes any trivial predicates.

      This feature is available in the commercial distribution only.

    • withTransformPatternsTrivialBitwiseOperations

      public Settings withTransformPatternsTrivialBitwiseOperations(Boolean value)
      Transform trivial bitwise comparisons like BIT_OR(a, 0) to a.

      This transformation removes any trivial predicates.

      This feature is available in the commercial distribution only.

    • withTransformPatternsBitSet

      public Settings withTransformPatternsBitSet(Boolean value)
      Transform bitwise operations to an equivalent BIT_SET(a, b) or BIT_SET(a, b, c) expression.

      This feature is available in the commercial distribution only.

    • withTransformPatternsBitGet

      public Settings withTransformPatternsBitGet(Boolean value)
      Transform bitwise operations to an equivalent BIT_GET(a, b) expression.

      This feature is available in the commercial distribution only.

    • withTransformPatternsScalarSubqueryCountAsteriskGtZero

      public Settings withTransformPatternsScalarSubqueryCountAsteriskGtZero(Boolean value)
      Transform predicates comparing scalar subqueries with a count (SELECT COUNT(*) …) > 0 to equivalent EXISTS (SELECT 1 …).

      Scalar subqueries that count rows and whose count is compared to 0 can be transformed into equivalent, but likely cheaper to execute EXISTS queries.

      This feature is available in the commercial distribution only.

    • withTransformPatternsScalarSubqueryCountExpressionGtZero

      public Settings withTransformPatternsScalarSubqueryCountExpressionGtZero(Boolean value)
      Transform predicates comparing scalar subqueries with a count (SELECT COUNT(expr) …) > 0 to equivalent EXISTS (SELECT 1 … WHERE expr IS NOT NULL).

      Scalar subqueries that count non-null expressions and whose count is compared to 0 can be transformed into equivalent, but likely cheaper to execute EXISTS queries.

      This feature is available in the commercial distribution only.

    • withTransformPatternsEmptyScalarSubquery

      public Settings withTransformPatternsEmptyScalarSubquery(Boolean value)
      Transform empty scalar subqueries like (SELECT 1 WHERE FALSE) to NULL.

      Scalar subqueries that are guaranteed to produce no results can be replaced by a NULL value.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNegNeg

      public Settings withTransformPatternsNegNeg(Boolean value)
      Transform -(-(x)) to x

      This transformation removes a redundant arithmetic negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsBitNotBitNot

      public Settings withTransformPatternsBitNotBitNot(Boolean value)
      Transform ~(~(x)) to x.

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsBitNotBitNand

      public Settings withTransformPatternsBitNotBitNand(Boolean value)
      Transform ~(bitnand(x, y)) to bitand(x, y) and ~(bitand(x, y) to bitnand(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsBitNotBitNor

      public Settings withTransformPatternsBitNotBitNor(Boolean value)
      Transform ~(bitnor(x, y)) to bitor(x, y) and ~(bitor(x, y) to bitnor(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsBitNotBitXNor

      public Settings withTransformPatternsBitNotBitXNor(Boolean value)
      Transform ~(bitxnor(x, y)) to bitxor(x, y) and ~(bitxor(x, y) to bitxnor(x, y).

      This transformation removes a redundant bitwise negation.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsNullOnNullInput

      public Settings withTransformPatternsNullOnNullInput(Boolean value)
      Any {org.jooq.impl.QOM.UReturnsNullOnNullInput} function or expression with NULL arguments can be replaced by NULL.

      There are many built-in SQL functions and operators with a RETURNS NULL ON NULL INPUT property, e.g.

      • ABS(NULL)
      • MOD(NULL, 1)
      • NULL + 1

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsIdempotentFunctionRepetition

      public Settings withTransformPatternsIdempotentFunctionRepetition(Boolean value)
      Transform all repetitions of idempotent functions, such as UPPER(UPPER(s)) to UPPER(s).

      Idempotent functions that are covered so far, include:

      • LTRIM(LTRIM(s)) to LTRIM(s)
      • LTRIM(TRIM(s)) to TRIM(s)
      • RTRIM(RTRIM(s)) to RTRIM(s)
      • RTRIM(TRIM(s)) to TRIM(s)
      • TRIM(LTRIM(s)) to TRIM(s)
      • TRIM(RTRIM(s)) to TRIM(s)
      • UPPER(UPPER(s)) to UPPER(s)
      • LOWER(LOWER(s)) to LOWER(s)

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsArithmeticComparisons

      public Settings withTransformPatternsArithmeticComparisons(Boolean value)
      Transform a + 1 = 2 to a = 2 - 1, and other transformations.

      It is usually best to compare single columns with constants or expressions to encourage index usage. While function based indexes are possible in some RDBMS, ordinary indexes are more reusable and should be preferred.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsArithmeticExpressions

      public Settings withTransformPatternsArithmeticExpressions(Boolean value)
      Transform 1 / y * x to x / y, and other transformations.

      This transformation simplifies arithmetic expressions.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsTrigonometricFunctions

      public Settings withTransformPatternsTrigonometricFunctions(Boolean value)
      Transform SIN(x) / COS(x) to TAN(x), and other transformations.

      This transformation turns expanded trignonometric function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsLogarithmicFunctions

      public Settings withTransformPatternsLogarithmicFunctions(Boolean value)
      Transform LN(value) / LN(base) to LOG(base, value), and other transformations.

      This transformation turns expanded logarithmic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsHyperbolicFunctions

      public Settings withTransformPatternsHyperbolicFunctions(Boolean value)
      Transform (EXP(x) - EXP(-x)) / 2 to SINH(x), and other transformations.

      This transformation turns expanded hyperbolic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformPatternsInverseHyperbolicFunctions

      public Settings withTransformPatternsInverseHyperbolicFunctions(Boolean value)
      Transform LN(x + SQRT(SQUARE(x) + 1)) to ASINH(x), and other transformations.

      This transformation turns expanded inverse hyperbolic function definitions into their shorter equivalents.

      To enable this feature, transformPatterns must be enabled as well.

      This feature is available in the commercial distribution only.

    • withTransformInlineBindValuesForFieldComparisons

      public Settings withTransformInlineBindValuesForFieldComparisons(Boolean value)
      Transform QOM.CompareCondition and a few other types of condition to inline their bind values, in case they match

      Historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. For backwards compatibility with older RDBMS versions, ANSI joins in jOOQ code may be converted to equivalent table lists in generated SQL using this flag.

      This flag has a limited implementation that supports inner joins (in most cases) and outer joins (only for simple comparison predicates).

      This feature is available in the commercial distribution only.

    • withTransformAnsiJoinToTableLists

      public Settings withTransformAnsiJoinToTableLists(Boolean value)
      Transform ANSI join to table lists if possible.

      Historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. For backwards compatibility with older RDBMS versions, ANSI joins in jOOQ code may be converted to equivalent table lists in generated SQL using this flag.

      This flag has a limited implementation that supports inner joins (in most cases) and outer joins (only for simple comparison predicates).

      This feature is available in the commercial distribution only.

    • withTransformInConditionSubqueryWithLimitToDerivedTable

      @Deprecated public Settings withTransformInConditionSubqueryWithLimitToDerivedTable(Transformation value)
      Deprecated.
      - 3.18.0 - [#14634] - The configuration of this transformation is deprecated. It will no longer be commercially available only, but apply also to the jOOQ Open Source Edition, when required.
      Transform a subquery from an IN condition with LIMIT to an equivalent derived table.

      This transformation works around a known MySQL limitation "ERROR 1235 (42000): This version of MySQL doesn't yet support 'LIMIT invalid input: '&' IN/ALL/ANY/SOME subquery'"

      This feature is available in the commercial distribution only.

    • withTransformQualify

      public Settings withTransformQualify(Transformation value)
      Transform the QUALIFY clause to an equivalent derived table to filter on window functions.

      This feature is available in the commercial distribution only.

    • withTransformTableListsToAnsiJoin

      public Settings withTransformTableListsToAnsiJoin(Boolean value)
      Transform table lists to ANSI join if possible.

      (Very) historically, prior to ANSI join syntax, joins were implemented by listing tables in the FROM clause and providing join predicates in the WHERE clause, possibly using vendor specific operators like (+) (Oracle, DB2) or *= (SQL Server) for outer join support. Migrating such join syntax is tedious. The jOOQ parser can parse the old syntax and this flag enables the transformation to ANSI join syntax.

      This feature is available in the commercial distribution only.

    • withTransformRownum

      public Settings withTransformRownum(Transformation value)
      Transform ROWNUM expressions to corresponding LIMIT clauses or ROW_NUMBER() expressions.

      In Oracle 11g and less, ROWNUM filtering was the most popular way to paginate. This pseudo column is not supported in other RDBMS, and should be replaced in Oracle 12c by the FETCH clause or ROW_NUMBER() OVER () filtering. This transformation allows for replacing such a filter by equivalent SQL, if possible.

      This feature is available in the commercial distribution only.

    • withTransformUnneededArithmeticExpressions

      public Settings withTransformUnneededArithmeticExpressions(TransformUnneededArithmeticExpressions value)
      Transform arithmetic expressions on literals and bind variables.

      Arithmetic expressions may be implemented by the user, or arise from emulations from within jOOQ. Expressions on literals and bind variables could be evaluated in the client prior to generating SQL.

      This feature is available in the commercial distribution only.

    • withTransformGroupByColumnIndex

      public Settings withTransformGroupByColumnIndex(Transformation value)
      Transform GROUP BY [column index] clauses by substituting the column index.

      Not all dialects support grouping by column index, which is a convenient but also a bit confusing feature of some dialects. jOOQ can transform the syntax into an equivalent syntax where the referenced SELECT expression is duplicated into the GROUP BY clause.

      This feature is available in the commercial distribution only.

    • withTransformInlineCTE

      public Settings withTransformInlineCTE(Transformation value)
      Transform Common Table Expressions (CTE) by inlining their WITH clause definition to wherever they're referenced.

      Non-recursive CTE are just syntax sugar for inline views (derived tables). When they're not supported natively, jOOQ can simply inline their definition to wherever they're referenced.

      This feature is available in the commercial distribution only.

    • withBackslashEscaping

      public Settings withBackslashEscaping(BackslashEscaping value)
      Whether string literals should be escaped with backslash.
    • withParamType

      public Settings withParamType(ParamType value)
      Specify how bind variables are to be rendered.

      Possibilities include: - question marks - named parameters - named or inlined parameters - inlined parameters This value is overridden by statementType == STATIC_STATEMENT, in case of which, this defaults to INLINED

    • withParamCastMode

      public Settings withParamCastMode(ParamCastMode value)
      Whether rendered bind values should be cast to their respective type.
    • withStatementType

      public Settings withStatementType(StatementType value)
      The type of statement that is to be executed.
    • withInlineThreshold

      public Settings withInlineThreshold(Integer value)
      The maximum number of allowed bind variables before inlining all values where 0 uses the dialect defaults:
    • withTransactionListenerStartInvocationOrder

      public Settings withTransactionListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered TransactionListeners.
    • withTransactionListenerEndInvocationOrder

      public Settings withTransactionListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered TransactionListeners.
    • withMigrationListenerStartInvocationOrder

      public Settings withMigrationListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered MigrationListeners.
    • withMigrationListenerEndInvocationOrder

      public Settings withMigrationListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered MigrationListeners.
    • withVisitListenerStartInvocationOrder

      public Settings withVisitListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered VisitListeners.
    • withVisitListenerEndInvocationOrder

      public Settings withVisitListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered VisitListeners.
    • withRecordListenerStartInvocationOrder

      public Settings withRecordListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered RecordListeners.
    • withRecordListenerEndInvocationOrder

      public Settings withRecordListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered RecordListeners.
    • withExecuteListenerStartInvocationOrder

      public Settings withExecuteListenerStartInvocationOrder(InvocationOrder value)
      The order of invocation for [action]start() methods registered ExecuteListeners.
    • withExecuteListenerEndInvocationOrder

      public Settings withExecuteListenerEndInvocationOrder(InvocationOrder value)
      The order of invocation for [action]end() methods registered ExecuteListeners.
    • withExecuteLogging

      public Settings withExecuteLogging(Boolean value)
      When set to true, this will add jOOQ's default LoggerListener for debug logging. This is meant for use in development only.
    • withExecuteLoggingSQLExceptions

      public Settings withExecuteLoggingSQLExceptions(Boolean value)
      [#14420] Whether constraint violations and other SQLException should produce additional log information about the column name and data causing the problem. Unlike executeLogging, this is meant for use in production as well as development. This feature is available only in commercial distributions.
    • withDiagnosticsLogging

      public Settings withDiagnosticsLogging(Boolean value)
      When set to true, this will add jOOQ's default logging DiagnosticsListeners.
    • withDiagnosticsConnection

      public Settings withDiagnosticsConnection(DiagnosticsConnection value)
      Whether to activate the DiagnosticsConnection, explicit by DEFAULT, implicit if ON, or turned OFF entirely.
    • withUpdateRecordVersion

      public Settings withUpdateRecordVersion(Boolean value)
      Whether store(), insert(), and update() methods should update the record version prior to the operation, for use with executeWithOptimisticLocking.
    • withUpdateRecordTimestamp

      public Settings withUpdateRecordTimestamp(Boolean value)
      Whether store(), insert(), and update() methods should update the record timestamp prior to the operation, for use with executeWithOptimisticLocking.
    • withExecuteWithOptimisticLocking

      public Settings withExecuteWithOptimisticLocking(Boolean value)
      Whether store() and delete() methods should be executed with optimistic locking.
    • withExecuteWithOptimisticLockingExcludeUnversioned

      public Settings withExecuteWithOptimisticLockingExcludeUnversioned(Boolean value)
      Whether store() and delete() methods should be executed with optimistic locking also on "unversioned" tables, i.e. on tables that do not have a version and/or timestamp column.

      This flag has no effect when "executeWithOptimisticLocking" is turned off.

    • withAttachRecords

      public Settings withAttachRecords(Boolean value)
      Whether fetched records should be attached to the fetching configuration.
    • withInsertUnchangedRecords

      public Settings withInsertUnchangedRecords(Boolean value)
      Whether TableRecord.insert() calls should be executed if the record is unchanged. This also affects the INSERT part of UpdatableRecord.store() and UpdatableRecord.merge() calls.
    • withUpdateUnchangedRecords

      public Settings withUpdateUnchangedRecords(UpdateUnchangedRecords value)
      Whether UpdatableRecord.update() calls should be executed if the record is unchanged. This also affects the UPDATE part of UpdatableRecord.store() and UpdatableRecord.merge() calls.
    • withUpdatablePrimaryKeys

      public Settings withUpdatablePrimaryKeys(Boolean value)
      Whether primary key values are deemed to be "updatable" in jOOQ.

      Setting this to "true" will allow for updating primary key values through UpdatableRecord.store() and UpdatableRecord.update().

    • withReflectionCaching

      public Settings withReflectionCaching(Boolean value)
      Whether reflection information should be cached in the configuration.
    • withCacheRecordMappers

      public Settings withCacheRecordMappers(Boolean value)
      Whether record mappers should be cached in the configuration.
    • withCacheParsingConnection

      public Settings withCacheParsingConnection(Boolean value)
      Whether parsing connection translations should be cached in the configuration.
    • withCacheParsingConnectionLRUCacheSize

      public Settings withCacheParsingConnectionLRUCacheSize(Integer value)
      The default implementation of the ParsingConnection cache's LRU cache size.
    • withCachePreparedStatementInLoader

      public Settings withCachePreparedStatementInLoader(Boolean value)
      Whether JDBC PreparedStatement instances should be cached in loader API.
    • withThrowExceptions

      public Settings withThrowExceptions(ThrowExceptions value)
      A strategy defining how exceptions from the database / JDBC driver should be propagated
    • withFetchWarnings

      public Settings withFetchWarnings(Boolean value)
      Whether warnings should be fetched after each query execution.
    • withFetchServerOutputSize

      public Settings withFetchServerOutputSize(Integer value)
      Whether server output should be fetched after each query execution.
    • withReturnIdentityOnUpdatableRecord

      public Settings withReturnIdentityOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return the identity column.
    • withReturnDefaultOnUpdatableRecord

      public Settings withReturnDefaultOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return values for columns that are DataType.defaulted().
    • withReturnComputedOnUpdatableRecord

      public Settings withReturnComputedOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return values for columns that are DataType.computed().
    • withReturnAllOnUpdatableRecord

      public Settings withReturnAllOnUpdatableRecord(Boolean value)
      Whether calls to store(), insert() and update() should return all columns, not just identity columns.

      Do note that only few databases support this feature. It is supported only in case the INSERT's or UPDATE's RETURNING clause is fully supported, also for non-IDENTITY columns.

    • withReturnRecordToPojo

      public Settings withReturnRecordToPojo(Boolean value)
      Whether calls to store(), insert(), update(), and delete() that are called on an UpdatableRecord that is created from a POJO (e.g. in a DAO) should return all Record values to the POJO, including IDENTITY values, and if returnAllOnUpdatableRecord is active, also other values.
    • withMapJPAAnnotations

      public Settings withMapJPAAnnotations(Boolean value)
      Whether JPA annotations should be considered by the DefaultRecordMapper.
    • withMapRecordComponentParameterNames

      public Settings withMapRecordComponentParameterNames(Boolean value)
      Whether constructor parameter names obtained from the Record component names should be considered by the DefaultRecordMapper.
    • withMapConstructorPropertiesParameterNames

      public Settings withMapConstructorPropertiesParameterNames(Boolean value)
      Whether constructor parameter names obtained from the ConstructorProperties annotation should be considered by the DefaultRecordMapper.
    • withMapConstructorParameterNames

      public Settings withMapConstructorParameterNames(Boolean value)
      Whether constructor parameter names obtained via reflection in Java 8+ should be considered by the DefaultRecordMapper. This flag has no effect in Java 6 or 7.
    • withMapConstructorParameterNamesInKotlin

      public Settings withMapConstructorParameterNamesInKotlin(Boolean value)
      Whether constructor parameter names obtained via reflection in Kotlin should be considered by the DefaultRecordMapper. This flag has no effect in Java.
    • withQueryPoolable

      public Settings withQueryPoolable(QueryPoolable value)
      The default JDBC poolable property that should be applied to all jOOQ queries, for which no specific poolable flag was specified.
    • withQueryTimeout

      public Settings withQueryTimeout(Integer value)
      The default JDBC queryTimeout property that should be applied to all jOOQ queries, for which no specific queryTimeout was specified.
    • withMaxRows

      public Settings withMaxRows(Integer value)
      The default JDBC maxRows property that should be applied to all jOOQ queries, for which no specific maxRows value was specified.
    • withFetchSize

      public Settings withFetchSize(Integer value)
      The default JDBC fetchSize property that should be applied to all jOOQ queries, for which no specific fetchSize value was specified.
    • withBatchSize

      public Settings withBatchSize(Integer value)
      A property specifying a batch size that should be applied to all automatically created BatchedConnection instances.
    • withDebugInfoOnStackTrace

      public Settings withDebugInfoOnStackTrace(Boolean value)
      [#5570] Whether exception stack traces should be enhanced with additional debug information.
    • withInListPadding

      public Settings withInListPadding(Boolean value)
      [#5600] Whether IN lists in IN predicates should be padded to powers of inListPadBase (default 2).
    • withInListPadBase

      public Settings withInListPadBase(Integer value)
      [#7095] The base to use to calculate the powers of when applying in list padding.
    • withDelimiter

      public Settings withDelimiter(String value)
      [#5826] The delimiter character to be used to delimit statements in batches.
    • withEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly

      public Settings withEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly(Boolean value)
      [#6462] Use only the primary key to emulate MySQL's INSERT .. ON DUPLICATE KEY UPDATE statement. In MySQL, the statement considers all unique keys for duplicates to apply an update rather than an insert. Earlier versions of jOOQ considered only the PRIMARY KEY. This flag can be turned on to maintain backwards compatibility.
    • withEmulateMultiset

      public Settings withEmulateMultiset(NestedCollectionEmulation value)
      [#3884] How MULTISET support should be emulated.
    • withEmulateComputedColumns

      public Settings withEmulateComputedColumns(Boolean value)
      [#13418] Whether computed columns should be emulated in the client.

      This can be useful if a schema was generated using a dialect that supports computed columns, but it is deployed on an RDBMS that does not.

    • withExecuteUpdateWithoutWhere

      public Settings withExecuteUpdateWithoutWhere(ExecuteWithoutWhere value)
      [#6771] Specifies whether UPDATE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
    • withExecuteDeleteWithoutWhere

      public Settings withExecuteDeleteWithoutWhere(ExecuteWithoutWhere value)
      [#6771] Specifies whether DELETE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
    • withInterpreterDialect

      public Settings withInterpreterDialect(SQLDialect value)
      [#7337] The dialect that should be used to interpret SQL DDL statements. SQLDialect.DEFAULT means that jOOQ interprets the SQL itself. Any other dialect (if supported) will be interpreted on an actual JDBC connection.
    • withInterpreterNameLookupCaseSensitivity

      public Settings withInterpreterNameLookupCaseSensitivity(InterpreterNameLookupCaseSensitivity value)
      [#9633] The case sensitivity of identifiers used when interpreting SQL DDL statements.
    • withInterpreterLocale

      public Settings withInterpreterLocale(Locale value)
      The Locale to be used with any interpreter locale dependent logic, defaulting to getLocale().
    • withInterpreterDelayForeignKeyDeclarations

      public Settings withInterpreterDelayForeignKeyDeclarations(Boolean value)
      Using this flag, the interpreter will be able to delay the addition of foreign key declarations until the end of the interpretation run.
    • withMetaIncludeSystemIndexes

      public Settings withMetaIncludeSystemIndexes(Boolean value)
      The Meta implementation that is backed by DatabaseMetaData does not produce system generated indexes on constraints, by default.
    • withMetaIncludeSystemSequences

      public Settings withMetaIncludeSystemSequences(Boolean value)
      The Meta implementation that is backed by DatabaseMetaData does not produce system generated sequences, by default.
    • withMigrationHistorySchema

      public Settings withMigrationHistorySchema(MigrationSchema value)
      The database schema where the migration history is located.
    • withMigrationHistorySchemaCreateSchemaIfNotExists

      public Settings withMigrationHistorySchemaCreateSchemaIfNotExists(Boolean value)
      Whether getMigrationHistorySchema() should be created if it doesn't exist.
    • withMigrationDefaultSchema

      public Settings withMigrationDefaultSchema(MigrationSchema value)
      The default schema whose unqualified objects that are included in the migration.
    • withMigrationSchemataCreateSchemaIfNotExists

      public Settings withMigrationSchemataCreateSchemaIfNotExists(Boolean value)
      Whether getMigrationSchemata() should be created if they don't exist.
    • withMigrationAllowsUndo

      public Settings withMigrationAllowsUndo(Boolean value)
      Whether migrations are allowed to be executed in inverse order.

      This is a potentially destructive feature, which should not be turned on in production. It is useful mostly to quickly switch between branches in a development environment. This feature is available only in commercial distributions.

    • withMigrationRevertUntracked

      public Settings withMigrationRevertUntracked(Boolean value)
      Whether migrations revert any untracked changes in the schemas that are being migrated.

      This is a potentially destructive feature, which should not be turned on in production. It is useful mostly to quickly revert any elements created in a development environment. This feature is available only in commercial distributions.

    • withMigrationAutoBaseline

      public Settings withMigrationAutoBaseline(Boolean value)
      Whether to automatically existing schemas that are not yet managed by jOOQ Migrations.
    • withMigrationAutoVerification

      public Settings withMigrationAutoVerification(Boolean value)
      Whether a migration automatically runs a verification first.
    • withMigrationIgnoreDefaultTimestampPrecisionDiffs

      public Settings withMigrationIgnoreDefaultTimestampPrecisionDiffs(Boolean value)
      Various migrateTo() methods (e.g. Meta.migrateTo(org.jooq.Meta)) ignore the difference between TIMESTAMP and TIMESTAMP(6), if 6 is the default precision for timestamps on the configured dialect.
    • withLocale

      public Settings withLocale(Locale value)
      The Locale to be used with any locale dependent logic if there is not a more specific locale available. More specific locales include e.g. getRenderLocale(), getParseLocale(), or getInterpreterLocale().
    • withParseDialect

      public Settings withParseDialect(SQLDialect value)
      [#7337] The input dialect that should be chosen to disambiguate ambiguous SQL syntax.
    • withParseLocale

      public Settings withParseLocale(Locale value)
      The Locale to be used with any parser locale dependent logic, defaulting to getLocale().
    • withParseDateFormat

      public Settings withParseDateFormat(String value)
      The date format to use when parsing functions whose behaviour depends on some session date format, such as NLS_DATE_FORMAT in Oracle
    • withParseTimestampFormat

      public Settings withParseTimestampFormat(String value)
      The timestamp format to use when parsing functions whose behaviour depends on some session date format, such as NLS_TIMESTAMP_FORMAT in Oracle
    • withParseNamedParamPrefix

      public Settings withParseNamedParamPrefix(String value)
      The prefix to use for named parameters in parsed SQL.

      Named parameter syntax defaults to :name (such as supported by Oracle, JPA, Spring), but vendor specific parameters may look differently. This flag can be used to determine the prefix to be used by named parameters, such as @ for SQL Server's @name or $ for PostgreSQL's $name when parsing SQL.

      "Named indexed" parameters can be obtained in the same way by specifingy ParamType#NAMED and not providing a name to parameters, resulting in :1 or @1 or $1, etc.

    • withParseNameCase

      public Settings withParseNameCase(ParseNameCase value)
      [#7337] The default name case for parsed identifiers.
    • withParseWithMetaLookups

      public Settings withParseWithMetaLookups(ParseWithMetaLookups value)
      [#7163] Whether the parser should perform meta lookups in the Configuration's MetaProvider.
    • withParseAppendMissingTableReferences

      public Settings withParseAppendMissingTableReferences(Transformation value)
      Transform the parsed SQL to append missing table references to the query's FROM or USING clause, if applicable.

      Teradata (and possibly others) allow for referencing tables that are not listed in the FROM clause, such as SELECT t.* FROM t WHERE t.i = u.i. This transformation is executed in the parser, to produce SELECT t.* FROM t, u WHERE t.i = u.i, instead. By default, it is active when the input dialect supports this syntax.

      This feature is available in the commercial distribution only.

    • withParseSetCommands

      public Settings withParseSetCommands(Boolean value)
      [#9780] Whether commands of the type SET key = value should be parsed rather than ignored.
    • withParseUnsupportedSyntax

      public Settings withParseUnsupportedSyntax(ParseUnsupportedSyntax value)
      [#5917] Whether the parser should accept unsupported (but known) syntax.
    • withParseUnknownFunctions

      public Settings withParseUnknownFunctions(ParseUnknownFunctions value)
      [#7344] Whether the parser should accept unknown functions.
    • withParseIgnoreCommercialOnlyFeatures

      public Settings withParseIgnoreCommercialOnlyFeatures(Boolean value)
      [#13109] Whether the parser of the jOOQ Open Source Edition should ignore commercial only features, rather than failing.
    • withParseIgnoreComments

      public Settings withParseIgnoreComments(Boolean value)
      [#8325] Whether the parser should ignore content between ignore comment tokens.
    • withParseIgnoreCommentStart

      public Settings withParseIgnoreCommentStart(String value)
      [#8325] The ignore comment start token
    • withParseIgnoreCommentStop

      public Settings withParseIgnoreCommentStop(String value)
      [#8325] The ignore comment stop token
    • withParseRetainCommentsBetweenQueries

      public Settings withParseRetainCommentsBetweenQueries(Boolean value)
      [#12538] Whether the parser should retain comments and whitespace between queries when parsing multiple queries through Parser.parse(String).

      jOOQ's query object model doesn't have a way to represent comments or other whitespace, and as such, the parser simply skips them by default. However, it may be desirable to retain comments before or in between top level queries, when parsing multiple such queries in a script. Comments inside of queries (including procedural statements) are still not supported.

    • withParseMetaDefaultExpressions

      public Settings withParseMetaDefaultExpressions(Boolean value)
      [#8469] Whether to parse default expressions retrieved from DatabaseMetaData.
    • withParseMetaViewSources

      public Settings withParseMetaViewSources(Boolean value)
      [#8469] Whether to parse view sources retrieved from DatabaseMetaData.
    • withReadonlyTableRecordInsert

      public Settings withReadonlyTableRecordInsert(WriteIfReadonly value)
      [#9864] The behaviour when trying to insert into readonly columns using TableRecord.insert().
    • withReadonlyUpdatableRecordUpdate

      public Settings withReadonlyUpdatableRecordUpdate(WriteIfReadonly value)
      [#9864] The behaviour when trying to update a readonly column using UpdatableRecord.update().
    • withReadonlyInsert

      public Settings withReadonlyInsert(WriteIfReadonly value)
      [#9864] The behaviour when trying to insert into readonly columns using Insert statements, or the insert clause of a Merge statement.
    • withReadonlyUpdate

      public Settings withReadonlyUpdate(WriteIfReadonly value)
      [#9864] The behaviour when trying to update a readonly column using Update statements, or the update clause of a Merge statement.
    • withApplyWorkaroundFor7962

      public Settings withApplyWorkaroundFor7962(Boolean value)
      [#7963] Apply workaround for ORA-04043 when inserting into Oracle tables with qualified, quoted identifiers, and fetching generated keys
    • withWarnOnStaticTypeRegistryAccess

      public Settings withWarnOnStaticTypeRegistryAccess(Warning value)
      [#15286] The warning level when the deprecated static type registry was accessed by legacy code.
    • withInterpreterSearchPath

      public Settings withInterpreterSearchPath(InterpreterSearchSchema... values)
    • withInterpreterSearchPath

      public Settings withInterpreterSearchPath(Collection<InterpreterSearchSchema> values)
    • withInterpreterSearchPath

      public Settings withInterpreterSearchPath(List<InterpreterSearchSchema> interpreterSearchPath)
    • withMigrationSchemata

      public Settings withMigrationSchemata(MigrationSchema... values)
    • withMigrationSchemata

      public Settings withMigrationSchemata(Collection<MigrationSchema> values)
    • withMigrationSchemata

      public Settings withMigrationSchemata(List<MigrationSchema> migrationSchemata)
    • withParseSearchPath

      public Settings withParseSearchPath(ParseSearchSchema... values)
    • withParseSearchPath

      public Settings withParseSearchPath(Collection<ParseSearchSchema> values)
    • withParseSearchPath

      public Settings withParseSearchPath(List<ParseSearchSchema> parseSearchPath)
    • appendTo

      public final void appendTo(XMLBuilder builder)
      Specified by:
      appendTo in interface XMLAppendable
    • toString

      public String toString()
      Overrides:
      toString in class Object
    • equals

      public boolean equals(Object that)
      Overrides:
      equals in class Object
    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object
    • clone

      public Object clone()
      Overrides:
      clone in class Object