diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/AltibaseDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/AltibaseDialect.java index 9a3b1d2819b4..1503ff109cbb 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/AltibaseDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/AltibaseDialect.java @@ -102,33 +102,18 @@ public AltibaseDialect(DatabaseVersion version) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - return "char(1)"; - case FLOAT: - case DOUBLE: - return "double"; - case TINYINT: - return "smallint"; - case TIME: - case TIMESTAMP: - case TIME_WITH_TIMEZONE: - case TIMESTAMP_WITH_TIMEZONE: - return "date"; - case BINARY: - return "byte($l)"; - case VARBINARY: - return "varbyte($l)"; - case LONGVARBINARY: - return "blob"; - case BIT: - return "varbit($l)"; - case LONGVARCHAR: - case NCLOB: - return "clob"; - default: - return super.columnType( sqlTypeCode ); - } + return switch ( sqlTypeCode ) { + case BOOLEAN -> "char(1)"; + case FLOAT, DOUBLE -> "double"; + case TINYINT -> "smallint"; + case TIME, TIMESTAMP, TIME_WITH_TIMEZONE, TIMESTAMP_WITH_TIMEZONE -> "date"; + case BINARY -> "byte($l)"; + case VARBINARY -> "varbyte($l)"; + case LONGVARBINARY -> "blob"; + case BIT -> "varbit($l)"; + case LONGVARCHAR, NCLOB -> "clob"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -165,22 +150,11 @@ public int getDefaultStatementBatchSize() { @Override public String trimPattern(TrimSpec specification, boolean isWhitespace) { - switch ( specification ) { - case BOTH: - return isWhitespace - ? "trim(?1)" - : "trim(?1,?2)"; - case LEADING: - return isWhitespace - ? "ltrim(?1)" - : "ltrim(?1,?2)"; - case TRAILING: - return isWhitespace - ? "rtrim(?1)" - : "rtrim(?1,?2)"; - } - - return super.trimPattern( specification, isWhitespace ); + return switch ( specification ) { + case BOTH -> isWhitespace ? "trim(?1)" : "trim(?1,?2)"; + case LEADING -> isWhitespace ? "ltrim(?1)" : "ltrim(?1,?2)"; + case TRAILING -> isWhitespace ? "rtrim(?1)": "rtrim(?1,?2)"; + }; } @Override @@ -323,51 +297,36 @@ public long getFractionalSecondPrecisionInNanos() { */ @Override public String extractPattern(TemporalUnit unit) { - switch (unit) { - case DAY_OF_WEEK: - return "extract(?2, 'DAYOFWEEK')"; - case DAY_OF_MONTH: - return "extract(?2, 'DAY')"; - case DAY_OF_YEAR: - return "extract(?2,'DAYOFYEAR')"; - case WEEK: - return "to_number(to_char(?2,'IW'))"; //the ISO week number - case WEEK_OF_YEAR: - return "extract(?2, 'WEEK')"; - case EPOCH: - return timestampdiffPattern( TemporalUnit.SECOND, TemporalType.TIMESTAMP, TemporalType.TIMESTAMP ) + return switch (unit) { + case DAY_OF_WEEK -> "extract(?2, 'DAYOFWEEK')"; + case DAY_OF_MONTH -> "extract(?2, 'DAY')"; + case DAY_OF_YEAR -> "extract(?2,'DAYOFYEAR')"; + case WEEK -> "to_number(to_char(?2,'IW'))"; //the ISO week number + case WEEK_OF_YEAR -> "extract(?2, 'WEEK')"; + case EPOCH -> timestampdiffPattern( TemporalUnit.SECOND, TemporalType.TIMESTAMP, TemporalType.TIMESTAMP ) .replace( "?2", "TO_DATE('1970-01-01 00:00:00','YYYY-MM-DD HH24:MI:SS')" ) .replace( "?3", "?2" ); - case QUARTER: - return "extract(?2, 'QUARTER')"; - default: - return super.extractPattern( unit ); - } + case QUARTER -> "extract(?2, 'QUARTER')"; + default -> super.extractPattern( unit ); + }; } @Override public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, IntervalType intervalType) { - switch (unit) { - case NANOSECOND: - return "timestampadd(MICROSECOND,(?2)/1e3,?3)"; - case NATIVE: - return "timestampadd(SECOND, ?2, ?3)"; - default: - return "timestampadd(?1, ?2, ?3)"; - } + return switch (unit) { + case NANOSECOND -> "timestampadd(MICROSECOND,(?2)/1e3,?3)"; + case NATIVE -> "timestampadd(SECOND, ?2, ?3)"; + default -> "timestampadd(?1, ?2, ?3)"; + }; } @Override public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { - switch (unit) { - case SECOND: - case NATIVE: - return "datediff(?2, ?3, 'SECOND')"; - case NANOSECOND: - return "datediff(?2, ?3, 'MICROSECOND')*1e3"; - default: - return "datediff(?2, ?3, '?1')"; - } + return switch (unit) { + case SECOND, NATIVE -> "datediff(?2, ?3, 'SECOND')"; + case NANOSECOND -> "datediff(?2, ?3, 'MICROSECOND')*1e3"; + default -> "datediff(?2, ?3, '?1')"; + }; } @Override @@ -678,12 +637,12 @@ protected boolean supportsPredicateAsExpression() { @Override public String translateExtractField(TemporalUnit unit) { - switch ( unit ) { - case DAY_OF_MONTH: return "day"; - case DAY_OF_YEAR: return "dayofyear"; - case DAY_OF_WEEK: return "dayofweek"; - default: return super.translateExtractField( unit ); - } + return switch ( unit ) { + case DAY_OF_MONTH -> "day"; + case DAY_OF_YEAR -> "dayofyear"; + case DAY_OF_WEEK -> "dayofweek"; + default -> super.translateExtractField( unit ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CUBRIDDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CUBRIDDialect.java index 037f94c10486..1fa1021a7d5e 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CUBRIDDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CUBRIDDialect.java @@ -74,22 +74,16 @@ public CUBRIDDialect() { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - return "bit"; - case TINYINT: - return "smallint"; + return switch ( sqlTypeCode ) { + case BOOLEAN -> "bit"; + case TINYINT -> "smallint"; //'timestamp' has a very limited range //'datetime' does not support explicit precision //(always 3, millisecond precision) - case TIMESTAMP: - return "datetime"; - case TIME_WITH_TIMEZONE: - case TIMESTAMP_WITH_TIMEZONE: - return "datetimetz"; - default: - return super.columnType( sqlTypeCode ); - } + case TIMESTAMP -> "datetime"; + case TIME_WITH_TIMEZONE, TIMESTAMP_WITH_TIMEZONE -> "datetimetz"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -427,20 +421,14 @@ public long getFractionalSecondPrecisionInNanos() { */ @Override public String extractPattern(TemporalUnit unit) { - switch (unit) { - case SECOND: - return "(second(?2)+extract(millisecond from ?2)/1e3)"; - case DAY_OF_WEEK: - return "dayofweek(?2)"; - case DAY_OF_MONTH: - return "dayofmonth(?2)"; - case DAY_OF_YEAR: - return "dayofyear(?2)"; - case WEEK: - return "week(?2,3)"; //mode 3 is the ISO week - default: - return "?1(?2)"; - } + return switch (unit) { + case SECOND -> "(second(?2)+extract(millisecond from ?2)/1e3)"; + case DAY_OF_WEEK -> "dayofweek(?2)"; + case DAY_OF_MONTH ->"dayofmonth(?2)"; + case DAY_OF_YEAR -> "dayofyear(?2)"; + case WEEK -> "week(?2,3)"; //mode 3 is the ISO week + default -> "?1(?2)"; + }; } @Override @@ -450,14 +438,11 @@ public TimeZoneSupport getTimeZoneSupport() { @Override public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, IntervalType intervalType) { - switch (unit) { - case NANOSECOND: - return "adddate(?3,interval (?2)/1e6 millisecond)"; - case NATIVE: - return "adddate(?3,interval ?2 millisecond)"; - default: - return "adddate(?3,interval ?2 ?1)"; - } + return switch (unit) { + case NANOSECOND -> "adddate(?3,interval (?2)/1e6 millisecond)"; + case NATIVE -> "adddate(?3,interval ?2 millisecond)"; + default -> "adddate(?3,interval ?2 ?1)"; + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CacheDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CacheDialect.java index 1e3132cebd81..8f45163fb3bc 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CacheDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CacheDialect.java @@ -83,20 +83,14 @@ public CacheDialect(DialectResolutionInfo info) { protected String columnType(int sqlTypeCode) { // Note: For object <-> SQL datatype mappings see: // Configuration Manager > Advanced > SQL > System DDL Datatype Mappings - switch ( sqlTypeCode ) { - case BOOLEAN: - return "bit"; + return switch ( sqlTypeCode ) { + case BOOLEAN -> "bit"; //no explicit precision - case TIMESTAMP: - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp"; - case BLOB: - return "image"; - case CLOB: - return "text"; - default: - return super.columnType( sqlTypeCode ); - } + case TIMESTAMP, TIMESTAMP_WITH_TIMEZONE -> "timestamp"; + case BLOB -> "image"; + case CLOB -> "text"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -228,24 +222,18 @@ public String extractPattern(TemporalUnit unit) { @Override public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, IntervalType intervalType) { - switch (unit) { - case NANOSECOND: - case NATIVE: - return "dateadd(millisecond,(?2)/1e6,?3)"; - default: - return "dateadd(?1,?2,?3)"; - } + return switch (unit) { + case NANOSECOND, NATIVE -> "dateadd(millisecond,(?2)/1e6,?3)"; + default -> "dateadd(?1,?2,?3)"; + }; } @Override public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { - switch (unit) { - case NANOSECOND: - case NATIVE: - return "datediff(millisecond,?2,?3)*1e6"; - default: - return "datediff(?1,?2,?3)"; - } + return switch (unit) { + case NANOSECOND, NATIVE -> "datediff(millisecond,?2,?3)*1e6"; + default -> "datediff(?1,?2,?3)"; + }; } // DDL support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CockroachLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CockroachLegacyDialect.java index 21ecacf240ca..9c27922fe18d 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CockroachLegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CockroachLegacyDialect.java @@ -212,54 +212,31 @@ protected static DatabaseVersion parseVersion(String versionString ) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case TINYINT: - return "smallint"; //no tinyint - case INTEGER: - return "int4"; - - case NCHAR: - return columnType( CHAR ); - case NVARCHAR: - return columnType( VARCHAR ); - - case NCLOB: - case CLOB: - return "string"; - - case BINARY: - case VARBINARY: - case BLOB: - return "bytes"; + return switch ( sqlTypeCode ) { + case TINYINT -> "smallint"; //no tinyint + case INTEGER -> "int4"; + case NCHAR -> columnType( CHAR ); + case NVARCHAR -> columnType( VARCHAR ); + case NCLOB, CLOB -> "string"; + case BINARY, VARBINARY, BLOB -> "bytes"; // We do not use the time with timezone type because PG deprecated it and it lacks certain operations like subtraction // case TIME_UTC: // return columnType( TIME_WITH_TIMEZONE ); - case TIMESTAMP_UTC: - return columnType( TIMESTAMP_WITH_TIMEZONE ); + case TIMESTAMP_UTC -> columnType( TIMESTAMP_WITH_TIMEZONE ); - default: - return super.columnType( sqlTypeCode ); - } + default -> super.columnType( sqlTypeCode ); + }; } @Override protected String castType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case CHAR: - case NCHAR: - case VARCHAR: - case NVARCHAR: - case LONG32VARCHAR: - case LONG32NVARCHAR: - return "string"; - case BINARY: - case VARBINARY: - case LONG32VARBINARY: - return "bytes"; - } - return super.castType( sqlTypeCode ); + return switch ( sqlTypeCode ) { + case CHAR, NCHAR, VARCHAR, NVARCHAR, LONG32VARCHAR, LONG32NVARCHAR -> "string"; + case BINARY, VARBINARY, LONG32VARBINARY -> "bytes"; + default -> super.castType( sqlTypeCode ); + }; } @Override @@ -344,22 +321,16 @@ public JdbcType resolveSqlTypeDescriptor( @Override protected Integer resolveSqlTypeCode(String columnTypeName, TypeConfiguration typeConfiguration) { - switch ( columnTypeName ) { - case "bool": - return Types.BOOLEAN; - case "float4": - // Use REAL instead of FLOAT to get Float as recommended Java type - return Types.REAL; - case "float8": - return Types.DOUBLE; - case "int2": - return Types.SMALLINT; - case "int4": - return Types.INTEGER; - case "int8": - return Types.BIGINT; - } - return super.resolveSqlTypeCode( columnTypeName, typeConfiguration ); + return switch ( columnTypeName ) { + case "bool" -> Types.BOOLEAN; + // Use REAL instead of FLOAT to get Float as recommended Java type + case "float4" -> Types.REAL; + case "float8" -> Types.DOUBLE; + case "int2" -> Types.SMALLINT; + case "int4" -> Types.INTEGER; + case "int8" -> Types.BIGINT; + default -> super.resolveSqlTypeCode( columnTypeName, typeConfiguration ); + }; } @Override @@ -1188,19 +1159,15 @@ public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate() { if ( sqlState == null ) { return null; } - switch ( sqlState ) { - case "40P01": - // DEADLOCK DETECTED - return new LockAcquisitionException( message, sqlException, sql); - case "55P03": - // LOCK NOT AVAILABLE - return new PessimisticLockException( message, sqlException, sql); - case "57014": - return new QueryTimeoutException( message, sqlException, sql ); - default: - // returning null allows other delegates to operate - return null; - } + return switch ( sqlState ) { + // DEADLOCK DETECTED + case "40P01" -> new LockAcquisitionException( message, sqlException, sql); + // LOCK NOT AVAILABLE + case "55P03" -> new PessimisticLockException( message, sqlException, sql); + case "57014" -> new QueryTimeoutException( message, sqlException, sql ); + // returning null allows other delegates to operate + default -> null; + }; }; } diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CommunityDialectSelector.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CommunityDialectSelector.java index 307f7fb9fed5..f261c5b1bcbe 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CommunityDialectSelector.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/CommunityDialectSelector.java @@ -17,43 +17,23 @@ public Class resolve(String name) { if ( name.isEmpty() ) { return null; } - switch ( name ) { - case "Cache71": - case "Cache": - return CacheDialect.class; - case "CUBRID": - return CUBRIDDialect.class; - case "Altibase": - return AltibaseDialect.class; - case "Firebird": - return FirebirdDialect.class; - case "Informix10": - case "Informix": - return InformixDialect.class; - case "Ingres9": - case "Ingres10": - case "Ingres": - return IngresDialect.class; - case "MimerSQL": - return MimerSQLDialect.class; - case "RDMSOS2200": - return RDMSOS2200Dialect.class; - case "SAPDB": - case "MaxDB": - return MaxDBDialect.class; - case "SybaseAnywhere": - return SybaseAnywhereDialect.class; - case "Teradata14": - case "Teradata": - return TeradataDialect.class; - case "TimesTen": - return TimesTenDialect.class; - case "SingleStore": - return SingleStoreDialect.class; - case "Derby": - return DerbyDialect.class; - } - return null; + return switch ( name ) { + case "Cache71", "Cache" -> CacheDialect.class; + case "CUBRID" -> CUBRIDDialect.class; + case "Altibase" -> AltibaseDialect.class; + case "Firebird" -> FirebirdDialect.class; + case "Informix10", "Informix" -> InformixDialect.class; + case "Ingres9", "Ingres10", "Ingres" -> IngresDialect.class; + case "MimerSQL" -> MimerSQLDialect.class; + case "RDMSOS2200" -> RDMSOS2200Dialect.class; + case "SAPDB", "MaxDB" -> MaxDBDialect.class; + case "SybaseAnywhere" -> SybaseAnywhereDialect.class; + case "Teradata14", "Teradata" -> TeradataDialect.class; + case "TimesTen" -> TimesTenDialect.class; + case "SingleStore" -> SingleStoreDialect.class; + case "Derby" -> DerbyDialect.class; + default -> null; + }; } } diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2LegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2LegacyDialect.java index 9ff508aa8854..e14a1df282d8 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2LegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2LegacyDialect.java @@ -243,36 +243,25 @@ public int getPreferredSqlTypeCodeForBoolean() { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - // prior to DB2 11, the 'boolean' type existed, - // but was not allowed as a column type - return getDB2Version().isBefore( 11 ) ? "smallint" : super.columnType( sqlTypeCode ); - case TINYINT: - // no tinyint - return "smallint"; - case NUMERIC: - // HHH-12827: map them both to the same type to avoid problems with schema update - // Note that 31 is the maximum precision DB2 supports - return columnType( DECIMAL ); - case BLOB: - return "blob"; - case CLOB: - return "clob"; - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp($p)"; - case TIME: - case TIME_WITH_TIMEZONE: - return "time"; - case BINARY: - // should use 'binary' since version 11 - return getDB2Version().isBefore( 11 ) ? "char($l) for bit data" : super.columnType( sqlTypeCode ); - case VARBINARY: - // should use 'varbinary' since version 11 - return getDB2Version().isBefore( 11 ) ? "varchar($l) for bit data" : super.columnType( sqlTypeCode ); - default: - return super.columnType( sqlTypeCode ); - } + return switch ( sqlTypeCode ) { + // prior to DB2 11, the 'boolean' type existed, + // but was not allowed as a column type + case BOOLEAN -> getDB2Version().isBefore( 11 ) ? "smallint" : super.columnType( sqlTypeCode ); + // no tinyint + case TINYINT -> "smallint"; + // HHH-12827: map them both to the same type to avoid problems with schema update + // Note that 31 is the maximum precision DB2 supports + case NUMERIC -> columnType( DECIMAL ); + case BLOB -> "blob"; + case CLOB -> "clob"; + case TIMESTAMP_WITH_TIMEZONE -> "timestamp($p)"; + case TIME, TIME_WITH_TIMEZONE -> "time"; + // should use 'binary' since version 11 + case BINARY -> getDB2Version().isBefore( 11 ) ? "char($l) for bit data" : super.columnType( sqlTypeCode ); + // should use 'varbinary' since version 11 + case VARBINARY -> getDB2Version().isBefore( 11 ) ? "varchar($l) for bit data" : super.columnType( sqlTypeCode ); + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -561,28 +550,16 @@ public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalT toExpression = "?3"; } else { - switch ( fromTemporalType ) { - case DATE: - fromExpression = "cast(?2 as timestamp)"; - break; - case TIME: - fromExpression = "timestamp('1970-01-01',?2)"; - break; - default: - fromExpression = "?2"; - break; - } - switch ( toTemporalType ) { - case DATE: - toExpression = "cast(?3 as timestamp)"; - break; - case TIME: - toExpression = "timestamp('1970-01-01',?3)"; - break; - default: - toExpression = "?3"; - break; - } + fromExpression = switch ( fromTemporalType ) { + case DATE -> "cast(?2 as timestamp)"; + case TIME -> "timestamp('1970-01-01',?2)"; + default -> "?2"; + }; + toExpression = switch ( toTemporalType ) { + case DATE -> "cast(?3 as timestamp)"; + case TIME -> "timestamp('1970-01-01',?3)"; + default -> "?3"; + }; } switch ( unit ) { case NATIVE: @@ -1358,13 +1335,13 @@ public void appendDatetimeFormat(SqlAppender appender, String format) { @Override public String translateExtractField(TemporalUnit unit) { - switch ( unit ) { + return switch ( unit ) { //WEEK means the ISO week number on DB2 - case DAY_OF_MONTH: return "day"; - case DAY_OF_YEAR: return "doy"; - case DAY_OF_WEEK: return "dow"; - default: return super.translateExtractField( unit ); - } + case DAY_OF_MONTH -> "day"; + case DAY_OF_YEAR -> "doy"; + case DAY_OF_WEEK -> "dow"; + default -> super.translateExtractField( unit ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2zLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2zLegacyDialect.java index 1169e88b1125..3f1d6ed56553 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2zLegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DB2zLegacyDialect.java @@ -172,19 +172,11 @@ public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, final StringBuilder pattern = new StringBuilder(); pattern.append("add_"); switch (unit) { - case NATIVE: - case NANOSECOND: - pattern.append("second"); - break; - case WEEK: - //note: DB2 does not have add_weeks() - pattern.append("day"); - break; - case QUARTER: - pattern.append("month"); - break; - default: - pattern.append("?1"); + case NATIVE, NANOSECOND -> pattern.append("second"); + //note: DB2 does not have add_weeks() + case WEEK -> pattern.append("day"); + case QUARTER -> pattern.append("month"); + default -> pattern.append("?1"); } pattern.append("s("); final String timestampExpression; @@ -207,17 +199,10 @@ public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, pattern.append(timestampExpression); pattern.append(","); switch (unit) { - case NANOSECOND: - pattern.append("(?2)/1e9"); - break; - case WEEK: - pattern.append("(?2)*7"); - break; - case QUARTER: - pattern.append("(?2)*3"); - break; - default: - pattern.append("?2"); + case NANOSECOND -> pattern.append("(?2)/1e9"); + case WEEK -> pattern.append("(?2)*7"); + case QUARTER -> pattern.append("(?2)*3"); + default -> pattern.append("?2"); } pattern.append(")"); return pattern.toString(); diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyDialect.java index 6da693aca935..f6984901261e 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyDialect.java @@ -150,41 +150,21 @@ protected DatabaseVersion getMinimumSupportedVersion() { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case TINYINT: - //no tinyint - return "smallint"; - - case NUMERIC: - // HHH-12827: map them both to the same type to avoid problems with schema update - // Note that 31 is the maximum precision Derby supports - return columnType( DECIMAL ); - - case VARBINARY: - return "varchar($l) for bit data"; - - case NCHAR: - return columnType( CHAR ); - case NVARCHAR: - return columnType( VARCHAR ); - - case BLOB: - return "blob"; - case CLOB: - case NCLOB: - return "clob"; - - case TIME: - case TIME_WITH_TIMEZONE: - return "time"; - - case TIMESTAMP: - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp"; - - default: - return super.columnType( sqlTypeCode ); - } + return switch ( sqlTypeCode ) { + //no tinyint + case TINYINT -> "smallint"; + // HHH-12827: map them both to the same type to avoid problems with schema update + // Note that 31 is the maximum precision Derby supports + case NUMERIC -> columnType( DECIMAL ); + case VARBINARY -> "varchar($l) for bit data"; + case NCHAR -> columnType( CHAR ); + case NVARCHAR -> columnType( VARCHAR ); + case BLOB -> "blob"; + case CLOB, NCLOB -> "clob"; + case TIME, TIME_WITH_TIMEZONE -> "time"; + case TIMESTAMP, TIMESTAMP_WITH_TIMEZONE -> "timestamp"; + default -> super.columnType( sqlTypeCode ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyLegacyDialect.java index 791da6a11282..3aefecb45dae 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyLegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/DerbyLegacyDialect.java @@ -145,43 +145,22 @@ public DerbyLegacyDialect(DialectResolutionInfo info) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - return getVersion().isBefore( 10, 7 ) ? "smallint" : super.columnType( sqlTypeCode ); - case TINYINT: - //no tinyint - return "smallint"; - - case NUMERIC: - // HHH-12827: map them both to the same type to avoid problems with schema update - // Note that 31 is the maximum precision Derby supports - return columnType( DECIMAL ); - - case VARBINARY: - return "varchar($l) for bit data"; - - case NCHAR: - return columnType( CHAR ); - case NVARCHAR: - return columnType( VARCHAR ); - - case BLOB: - return "blob"; - case CLOB: - case NCLOB: - return "clob"; - - case TIME: - case TIME_WITH_TIMEZONE: - return "time"; - - case TIMESTAMP: - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp"; - - default: - return super.columnType( sqlTypeCode ); - } + return switch ( sqlTypeCode ) { + case BOOLEAN -> getVersion().isBefore( 10, 7 ) ? "smallint" : super.columnType( sqlTypeCode ); + //no tinyint + case TINYINT -> "smallint"; + // HHH-12827: map them both to the same type to avoid problems with schema update + // Note that 31 is the maximum precision Derby supports + case NUMERIC -> columnType( DECIMAL ); + case VARBINARY -> "varchar($l) for bit data"; + case NCHAR -> columnType( CHAR ); + case NVARCHAR -> columnType( VARCHAR ); + case BLOB -> "blob"; + case CLOB, NCLOB -> "clob"; + case TIME, TIME_WITH_TIMEZONE -> "time"; + case TIMESTAMP, TIMESTAMP_WITH_TIMEZONE -> "timestamp"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -435,39 +414,27 @@ protected SqlAstTranslator buildTranslator( */ @Override public String extractPattern(TemporalUnit unit) { - switch (unit) { - case DAY_OF_MONTH: - return "day(?2)"; - case DAY_OF_YEAR: - return "({fn timestampdiff(sql_tsi_day,date(char(year(?2),4)||'-01-01'),?2)}+1)"; - case DAY_OF_WEEK: - // Use the approach as outlined here: https://stackoverflow.com/questions/36357013/day-of-week-from-seconds-since-epoch - return "(mod(mod({fn timestampdiff(sql_tsi_day,{d '1970-01-01'},?2)}+4,7)+7,7)+1)"; - case WEEK: - // Use the approach as outlined here: https://www.sqlservercentral.com/articles/a-simple-formula-to-calculate-the-iso-week-number - // In SQL Server terms this is (DATEPART(dy,DATEADD(dd,DATEDIFF(dd,'17530101',@SomeDate)/7*7,'17530104'))+6)/7 - return "(({fn timestampdiff(sql_tsi_day,date(char(year(?2),4)||'-01-01'),{fn timestampadd(sql_tsi_day,{fn timestampdiff(sql_tsi_day,{d '1753-01-01'},?2)}/7*7,{d '1753-01-04'})})}+7)/7)"; - case QUARTER: - return "((month(?2)+2)/3)"; - case EPOCH: - return "{fn timestampdiff(sql_tsi_second,{ts '1970-01-01 00:00:00'},?2)}"; - default: - return "?1(?2)"; - } + return switch (unit) { + case DAY_OF_MONTH -> "day(?2)"; + case DAY_OF_YEAR -> "({fn timestampdiff(sql_tsi_day,date(char(year(?2),4)||'-01-01'),?2)}+1)"; + // Use the approach as outlined here: https://stackoverflow.com/questions/36357013/day-of-week-from-seconds-since-epoch + case DAY_OF_WEEK -> "(mod(mod({fn timestampdiff(sql_tsi_day,{d '1970-01-01'},?2)}+4,7)+7,7)+1)"; + // Use the approach as outlined here: https://www.sqlservercentral.com/articles/a-simple-formula-to-calculate-the-iso-week-number + // In SQL Server terms this is (DATEPART(dy,DATEADD(dd,DATEDIFF(dd,'17530101',@SomeDate)/7*7,'17530104'))+6)/7 + case WEEK -> "(({fn timestampdiff(sql_tsi_day,date(char(year(?2),4)||'-01-01'),{fn timestampadd(sql_tsi_day,{fn timestampdiff(sql_tsi_day,{d '1753-01-01'},?2)}/7*7,{d '1753-01-04'})})}+7)/7)"; + case QUARTER -> "((month(?2)+2)/3)"; + case EPOCH -> "{fn timestampdiff(sql_tsi_second,{ts '1970-01-01 00:00:00'},?2)}"; + default -> "?1(?2)"; + }; } @Override public String translateExtractField(TemporalUnit unit) { - switch (unit) { - case WEEK: - case DAY_OF_YEAR: - case DAY_OF_WEEK: - throw new UnsupportedOperationException("field type not supported on Derby: " + unit); - case DAY_OF_MONTH: - return "day"; - default: - return super.translateExtractField(unit); - } + return switch (unit) { + case WEEK, DAY_OF_YEAR, DAY_OF_WEEK -> throw new UnsupportedOperationException("field type not supported on Derby: " + unit); + case DAY_OF_MONTH -> "day"; + default -> super.translateExtractField(unit); + }; } /** @@ -527,13 +494,10 @@ public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, @Override public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { - switch (unit) { - case NANOSECOND: - case NATIVE: - return "{fn timestampdiff(sql_tsi_frac_second,?2,?3)}"; - default: - return "{fn timestampdiff(sql_tsi_?1,?2,?3)}"; - } + return switch (unit) { + case NANOSECOND, NATIVE -> "{fn timestampdiff(sql_tsi_frac_second,?2,?3)}"; + default -> "{fn timestampdiff(sql_tsi_?1,?2,?3)}"; + }; } @Override @@ -752,8 +716,7 @@ public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate() { ConstraintViolationException.ConstraintKind.UNIQUE, constraintName ); - case "40XL1": - case "40XL2": + case "40XL1", "40XL2": return new LockTimeoutException( message, sqlException, sql ); } } diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HANALegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HANALegacyDialect.java index 0a562746126c..2f93f805a350 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HANALegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HANALegacyDialect.java @@ -322,38 +322,24 @@ protected boolean isCloud() { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - return useLegacyBooleanType ? "tinyint" : super.columnType( sqlTypeCode ); - case NUMERIC: - //there is no 'numeric' type in HANA - return columnType( DECIMAL ); + return switch ( sqlTypeCode ) { + case BOOLEAN -> useLegacyBooleanType ? "tinyint" : super.columnType( sqlTypeCode ); + //there is no 'numeric' type in HANA + case NUMERIC -> columnType( DECIMAL ); //'double precision' syntax not supported - case DOUBLE: - return "double"; + case DOUBLE -> "double"; //no explicit precision - case TIME: - case TIME_WITH_TIMEZONE: - return "time"; - case TIMESTAMP: - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp"; + case TIME, TIME_WITH_TIMEZONE -> "time"; + case TIMESTAMP, TIMESTAMP_WITH_TIMEZONE -> "timestamp"; //there is no 'char' or 'nchar' type in HANA - case CHAR: - case VARCHAR: - return isUseUnicodeStringTypes() ? columnType( NVARCHAR ) : super.columnType( VARCHAR ); - case NCHAR: - return columnType( NVARCHAR ); - case LONG32VARCHAR: - return isUseUnicodeStringTypes() ? columnType( LONG32NVARCHAR ) : super.columnType( LONG32VARCHAR ); - case CLOB: - return isUseUnicodeStringTypes() ? columnType( NCLOB ) : super.columnType( CLOB ); + case CHAR, VARCHAR -> isUseUnicodeStringTypes() ? columnType( NVARCHAR ) : super.columnType( VARCHAR ); + case NCHAR -> columnType( NVARCHAR ); + case LONG32VARCHAR -> isUseUnicodeStringTypes() ? columnType( LONG32NVARCHAR ) : super.columnType( LONG32VARCHAR ); + case CLOB -> isUseUnicodeStringTypes() ? columnType( NCLOB ) : super.columnType( CLOB ); // map tinyint to smallint since tinyint is unsigned on HANA - case TINYINT: - return "smallint"; - default: - return super.columnType( sqlTypeCode ); - } + case TINYINT -> "smallint"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -576,22 +562,15 @@ public AggregateSupport getAggregateSupport() { */ @Override public String extractPattern(TemporalUnit unit) { - switch (unit) { - case DAY_OF_WEEK: - return "(mod(weekday(?2)+1,7)+1)"; - case DAY: - case DAY_OF_MONTH: - return "dayofmonth(?2)"; - case DAY_OF_YEAR: - return "dayofyear(?2)"; - case QUARTER: - return "((month(?2)+2)/3)"; - case EPOCH: - return "seconds_between('1970-01-01', ?2)"; - default: - //I think week() returns the ISO week number - return "?1(?2)"; - } + return switch (unit) { + case DAY_OF_WEEK -> "(mod(weekday(?2)+1,7)+1)"; + case DAY, DAY_OF_MONTH -> "dayofmonth(?2)"; + case DAY_OF_YEAR -> "dayofyear(?2)"; + case QUARTER -> "((month(?2)+2)/3)"; + case EPOCH -> "seconds_between('1970-01-01', ?2)"; + //I think week() returns the ISO week number + default -> "?1(?2)"; + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/PostgreSQLLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/PostgreSQLLegacyDialect.java index a00b1cc49d35..b9b74920d784 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/PostgreSQLLegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/PostgreSQLLegacyDialect.java @@ -227,63 +227,41 @@ public boolean getDefaultNonContextualLobCreation() { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case TINYINT: - // no tinyint, not even in Postgres 11 - return "smallint"; + return switch ( sqlTypeCode ) { + // no tinyint, not even in Postgres 11 + case TINYINT -> "smallint"; // there are no nchar/nvarchar types in Postgres - case NCHAR: - return columnType( CHAR ); - case NVARCHAR: - return columnType( VARCHAR ); + case NCHAR -> columnType( CHAR ); + case NVARCHAR -> columnType( VARCHAR ); // since there's no real difference between TEXT and VARCHAR, // except for the length limit, we can just use 'text' for the // "long" string types - case LONG32VARCHAR: - case LONG32NVARCHAR: - return "text"; - case BLOB: - case CLOB: - case NCLOB: - // use oid as the blob/clob type on Postgres because - // the JDBC driver doesn't allow using bytea/text through LOB APIs - return "oid"; + case LONG32VARCHAR, LONG32NVARCHAR -> "text"; + // use oid as the blob/clob type on Postgres because + // the JDBC driver doesn't allow using bytea/text through LOB APIs + case BLOB, CLOB, NCLOB -> "oid"; // use bytea as the "long" binary type (that there is no // real VARBINARY type in Postgres, so we always use this) - case BINARY: - case VARBINARY: - case LONG32VARBINARY: - return "bytea"; + case BINARY, VARBINARY, LONG32VARBINARY -> "bytea"; // We do not use the time with timezone type because PG deprecated it and it lacks certain operations like subtraction // case TIME_UTC: // return columnType( TIME_WITH_TIMEZONE ); - case TIMESTAMP_UTC: - return columnType( TIMESTAMP_WITH_TIMEZONE ); + case TIMESTAMP_UTC -> columnType( TIMESTAMP_WITH_TIMEZONE ); - default: - return super.columnType( sqlTypeCode ); - } + default -> super.columnType( sqlTypeCode ); + }; } @Override protected String castType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case CHAR: - case NCHAR: - case VARCHAR: - case NVARCHAR: - return "varchar"; - case LONG32VARCHAR: - case LONG32NVARCHAR: - return "text"; - case BINARY: - case VARBINARY: - case LONG32VARBINARY: - return "bytea"; - } - return super.castType( sqlTypeCode ); + return switch ( sqlTypeCode ) { + case CHAR, NCHAR, VARCHAR, NVARCHAR -> "varchar"; + case LONG32VARCHAR, LONG32NVARCHAR -> "text"; + case BINARY, VARBINARY, LONG32VARBINARY ->"bytea"; + default -> super.castType( sqlTypeCode ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/RDMSOS2200Dialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/RDMSOS2200Dialect.java index 226812df19fa..d1b5e23d78f8 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/RDMSOS2200Dialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/RDMSOS2200Dialect.java @@ -115,37 +115,20 @@ protected String columnType(int sqlTypeCode) { * Note that $l (dollar-L) will use the length value if provided. * Also new for Hibernate3 is the $p percision and $s (scale) parameters */ - switch ( sqlTypeCode ) { - case BOOLEAN: - case TINYINT: - return "smallint"; - case BIGINT: - return "numeric(19,0)"; + return switch ( sqlTypeCode ) { + case BOOLEAN, TINYINT -> "smallint"; + case BIGINT -> "numeric(19,0)"; //'varchar' is not supported in RDMS for OS 2200 //(but it is for other flavors of RDMS) //'character' means ASCII by default, 'unicode(n)' //means 'character(n) character set "UCS-2"' - case CHAR: - case NCHAR: - case VARCHAR: - case NVARCHAR: - case LONG32VARCHAR: - case LONG32NVARCHAR: - return "unicode($l)"; - case CLOB: - case NCLOB: - return "clob($l)"; + case CHAR, NCHAR, VARCHAR, NVARCHAR, LONG32VARCHAR, LONG32NVARCHAR -> "unicode($l)"; + case CLOB, NCLOB -> "clob($l)"; //no 'binary' nor 'varbinary' so use 'blob' - case BINARY: - case VARBINARY: - case LONG32VARBINARY: - case BLOB: - return "blob($l)"; - case TIMESTAMP_WITH_TIMEZONE: - return columnType( TIMESTAMP ); - default: - return super.columnType( sqlTypeCode ); - } + case BINARY, VARBINARY, LONG32VARBINARY, BLOB -> "blob($l)"; + case TIMESTAMP_WITH_TIMEZONE -> columnType( TIMESTAMP ); + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -265,42 +248,31 @@ public long getFractionalSecondPrecisionInNanos() { */ @Override public String extractPattern(TemporalUnit unit) { - switch (unit) { - case SECOND: - return "(second(?2)+microsecond(?2)/1e6)"; - case DAY_OF_WEEK: - return "dayofweek(?2)"; - case DAY_OF_MONTH: - return "dayofmonth(?2)"; - case DAY_OF_YEAR: - return "dayofyear(?2)"; - default: - return "?1(?2)"; - } + return switch (unit) { + case SECOND -> "(second(?2)+microsecond(?2)/1e6)"; + case DAY_OF_WEEK -> "dayofweek(?2)"; + case DAY_OF_MONTH -> "dayofmonth(?2)"; + case DAY_OF_YEAR -> "dayofyear(?2)"; + default -> "?1(?2)"; + }; } @Override public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, IntervalType intervalType) { - switch (unit) { - case NANOSECOND: - return "timestampadd('SQL_TSI_FRAC_SECOND',(?2)/1e3,?3)"; - case NATIVE: - return "timestampadd('SQL_TSI_FRAC_SECOND',?2,?3)"; - default: - return "dateadd('?1',?2,?3)"; - } + return switch (unit) { + case NANOSECOND -> "timestampadd('SQL_TSI_FRAC_SECOND',(?2)/1e3,?3)"; + case NATIVE -> "timestampadd('SQL_TSI_FRAC_SECOND',?2,?3)"; + default -> "dateadd('?1',?2,?3)"; + }; } @Override public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { - switch (unit) { - case NANOSECOND: - return "timestampdiff('SQL_TSI_FRAC_SECOND',?2,?3)*1e3"; - case NATIVE: - return "timestampdiff('SQL_TSI_FRAC_SECOND',?2,?3)"; - default: - return "dateadd('?1',?2,?3)"; - } + return switch (unit) { + case NANOSECOND -> "timestampdiff('SQL_TSI_FRAC_SECOND',?2,?3)*1e3"; + case NATIVE -> "timestampdiff('SQL_TSI_FRAC_SECOND',?2,?3)"; + default -> "dateadd('?1',?2,?3)"; + }; } // Dialect method overrides ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLiteDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLiteDialect.java index 24299cb39f60..27dab5bfd308 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLiteDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLiteDialect.java @@ -117,27 +117,17 @@ public SQLiteDialect(DatabaseVersion version) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case DECIMAL: - return getVersion().isBefore( 3 ) ? columnType( SqlTypes.NUMERIC ) : super.columnType( sqlTypeCode ); - case CHAR: - return getVersion().isBefore( 3 ) ? "char" : super.columnType( sqlTypeCode ); - case NCHAR: - return getVersion().isBefore( 3 ) ? "nchar" : super.columnType( sqlTypeCode ); + return switch ( sqlTypeCode ) { + case DECIMAL -> getVersion().isBefore( 3 ) ? columnType( SqlTypes.NUMERIC ) : super.columnType( sqlTypeCode ); + case CHAR -> getVersion().isBefore( 3 ) ? "char" : super.columnType( sqlTypeCode ); + case NCHAR -> getVersion().isBefore( 3 ) ? "nchar" : super.columnType( sqlTypeCode ); // No precision support - case FLOAT: - return "float"; - case TIMESTAMP: - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp"; - case TIME_WITH_TIMEZONE: - return "time"; - case BINARY: - case VARBINARY: - return "blob"; - default: - return super.columnType( sqlTypeCode ); - } + case FLOAT -> "float"; + case TIMESTAMP, TIMESTAMP_WITH_TIMEZONE -> "timestamp"; + case TIME_WITH_TIMEZONE -> "time"; + case BINARY, VARBINARY -> "blob"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -182,32 +172,20 @@ public UniqueDelegate getUniqueDelegate() { */ @Override public String extractPattern(TemporalUnit unit) { - switch ( unit ) { - case SECOND: - return "cast(strftime('%S.%f',?2) as double)"; - case MINUTE: - return "strftime('%M',?2)"; - case HOUR: - return "strftime('%H',?2)"; - case DAY: - case DAY_OF_MONTH: - return "(strftime('%d',?2)+1)"; - case MONTH: - return "strftime('%m',?2)"; - case YEAR: - return "strftime('%Y',?2)"; - case DAY_OF_WEEK: - return "(strftime('%w',?2)+1)"; - case DAY_OF_YEAR: - return "strftime('%j',?2)"; - case EPOCH: - return "strftime('%s',?2)"; - case WEEK: - // Thanks https://stackoverflow.com/questions/15082584/sqlite-return-wrong-week-number-for-2013 - return "((strftime('%j',date(?2,'-3 days','weekday 4'))-1)/7+1)"; - default: - return super.extractPattern(unit); - } + return switch ( unit ) { + case SECOND -> "cast(strftime('%S.%f',?2) as double)"; + case MINUTE -> "strftime('%M',?2)"; + case HOUR -> "strftime('%H',?2)"; + case DAY, DAY_OF_MONTH -> "(strftime('%d',?2)+1)"; + case MONTH -> "strftime('%m',?2)"; + case YEAR -> "strftime('%Y',?2)"; + case DAY_OF_WEEK -> "(strftime('%w',?2)+1)"; + case DAY_OF_YEAR -> "strftime('%j',?2)"; + case EPOCH -> "strftime('%s',?2)"; + // Thanks https://stackoverflow.com/questions/15082584/sqlite-return-wrong-week-number-for-2013 + case WEEK -> "((strftime('%j',date(?2,'-3 days','weekday 4'))-1)/7+1)"; + default -> super.extractPattern(unit); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SingleStoreDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SingleStoreDialect.java index 0c1cac9a73c9..038b9540e58b 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SingleStoreDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SingleStoreDialect.java @@ -277,22 +277,15 @@ public boolean useMaterializedLobWhenCapacityExceeded() { @Override public String extractPattern(TemporalUnit unit) { - switch ( unit ) { - case SECOND: - return "(second(?2)+microsecond(?2)/1e6)"; - case WEEK: - return "weekofyear(?2)"; - case DAY_OF_WEEK: - return "dayofweek(?2)"; - case DAY_OF_MONTH: - return "dayofmonth(?2)"; - case DAY_OF_YEAR: - return "dayofyear(?2)"; - case EPOCH: - return "unix_timestamp(?2)"; - default: - return "?1(?2)"; - } + return switch ( unit ) { + case SECOND -> "(second(?2)+microsecond(?2)/1e6)"; + case WEEK -> "weekofyear(?2)"; + case DAY_OF_WEEK -> "dayofweek(?2)"; + case DAY_OF_MONTH -> "dayofmonth(?2)"; + case DAY_OF_YEAR -> "dayofyear(?2)"; + case EPOCH -> "unix_timestamp(?2)"; + default -> "?1(?2)"; + }; } @Override @@ -325,14 +318,11 @@ public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { String fromType = fromTemporalType == TemporalType.TIME ? "to_timestamp(?2, 'HH24:MI:SS.FF6')" : "?2"; String toType = toTemporalType == TemporalType.TIME ? "to_timestamp(?3, 'HH24:MI:SS.FF6')" : "?3"; - switch ( unit ) { - case NANOSECOND: - return String.format( "timestampdiff(microsecond,%s,%s)*1e3", fromType, toType ); - case NATIVE: - return String.format( "timestampdiff(microsecond,%s,%s)", fromType, toType ); - default: - return String.format( "timestampdiff(?1,%s,%s)", fromType, toType ); - } + return switch ( unit ) { + case NANOSECOND -> String.format( "timestampdiff(microsecond,%s,%s)*1e3", fromType, toType ); + case NATIVE -> String.format( "timestampdiff(microsecond,%s,%s)", fromType, toType ); + default -> String.format( "timestampdiff(?1,%s,%s)", fromType, toType ); + }; } @Override @@ -700,34 +690,22 @@ public JdbcType resolveSqlTypeDescriptor( @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - return "bit"; - case TIMESTAMP: - return "datetime($p)"; - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp($p)"; - case TIME_WITH_TIMEZONE: - return "time($p)"; - case SqlTypes.NUMERIC: - return columnType( DECIMAL ); - case FLOAT: - // Avoid using float type because - // SingleStore has potential inaccuracy when using the = or != comparison operators on FLOAT columns in WHERE clause - return columnType( DOUBLE ); - case NCHAR: - return "char($l) character set utf8"; - case NVARCHAR: - return "varchar($l) character set utf8"; - case BLOB: - return "longblob"; - case NCLOB: - return "longtext character set utf8"; - case CLOB: - return "longtext"; - default: - return super.columnType( sqlTypeCode ); - } + return switch ( sqlTypeCode ) { + case BOOLEAN -> "bit"; + case TIMESTAMP -> "datetime($p)"; + case TIMESTAMP_WITH_TIMEZONE -> "timestamp($p)"; + case TIME_WITH_TIMEZONE -> "time($p)"; + case SqlTypes.NUMERIC -> columnType( DECIMAL ); + // Avoid using float type because + // SingleStore has potential inaccuracy when using the = or != comparison operators on FLOAT columns in WHERE clause + case FLOAT -> columnType( DOUBLE ); + case NCHAR -> "char($l) character set utf8"; + case NVARCHAR -> "varchar($l) character set utf8"; + case BLOB -> "longblob"; + case NCLOB -> "longtext character set utf8"; + case CLOB -> "longtext"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -745,30 +723,15 @@ public int getPreferredSqlTypeCodeForBoolean() { @Override protected String castType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - case BIT: - //special case for casting to Boolean - return "unsigned"; - case TINYINT: - case SMALLINT: - case INTEGER: - case BIGINT: - return "signed"; - case CHAR: - case VARCHAR: - case LONG32VARCHAR: - return "char"; - case NCHAR: - case NVARCHAR: - case LONG32NVARCHAR: - return "char character set utf8"; - case BINARY: - case VARBINARY: - case LONG32VARBINARY: - return "binary"; - } - return super.castType( sqlTypeCode ); + return switch ( sqlTypeCode ) { + //special case for casting to Boolean + case BOOLEAN, BIT -> "unsigned"; + case TINYINT, SMALLINT, INTEGER, BIGINT -> "signed"; + case CHAR, VARCHAR, LONG32VARCHAR -> "char"; + case NCHAR, NVARCHAR, LONG32NVARCHAR -> "char character set utf8"; + case BINARY, VARBINARY, LONG32VARBINARY -> "binary"; + default -> super.castType( sqlTypeCode ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseASELegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseASELegacyDialect.java index 535650ac9cb8..5abdc25acb20 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseASELegacyDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseASELegacyDialect.java @@ -103,23 +103,18 @@ public SybaseASELegacyDialect(DialectResolutionInfo info) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - // On Sybase ASE, the 'bit' type cannot be null, - // and cannot have indexes (while we don't use - // tinyint to store signed bytes, we can use it - // to store boolean values) - return "tinyint"; - case BIGINT: - // Sybase ASE didn't introduce 'bigint' until version 15.0 - return getVersion().isBefore( 15 ) ? "numeric(19,0)" : super.columnType( sqlTypeCode ); - case DATE: - return getVersion().isSameOrAfter( 12 ) ? "date" : super.columnType( sqlTypeCode ); - case TIME: - return getVersion().isSameOrAfter( 12 ) ? "time" : super.columnType( sqlTypeCode ); - default: - return super.columnType( sqlTypeCode ); - } + return switch ( sqlTypeCode ) { + // On Sybase ASE, the 'bit' type cannot be null, + // and cannot have indexes (while we don't use + // tinyint to store signed bytes, we can use it + // to store boolean values) + case BOOLEAN -> "tinyint"; + // Sybase ASE didn't introduce 'bigint' until version 15.0 + case BIGINT -> getVersion().isBefore( 15 ) ? "numeric(19,0)" : super.columnType( sqlTypeCode ); + case DATE -> getVersion().isSameOrAfter( 12 ) ? "date" : super.columnType( sqlTypeCode ); + case TIME -> getVersion().isSameOrAfter( 12 ) ? "time" : super.columnType( sqlTypeCode ); + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -288,31 +283,25 @@ public long getFractionalSecondPrecisionInNanos() { @Override public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, IntervalType intervalType) { - switch ( unit ) { - case NANOSECOND: - return "dateadd(ms,?2/1000000,?3)"; + return switch ( unit ) { + case NANOSECOND -> "dateadd(ms,?2/1000000,?3)"; // return "dateadd(mcs,?2/1000,?3)"; - case NATIVE: - return "dateadd(ms,?2,?3)"; + case NATIVE -> "dateadd(ms,?2,?3)"; // return "dateadd(mcs,?2,?3)"; - default: - return "dateadd(?1,?2,?3)"; - } + default -> "dateadd(?1,?2,?3)"; + }; } @Override public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { - switch ( unit ) { - case NANOSECOND: - return "(cast(datediff(ms,?2,?3) as numeric(21))*1000000)"; + return switch ( unit ) { + case NANOSECOND -> "(cast(datediff(ms,?2,?3) as numeric(21))*1000000)"; // return "(cast(datediff(mcs,?2,?3) as numeric(21))*1000)"; // } - case NATIVE: - return "cast(datediff(ms,?2,?3) as numeric(21))"; + case NATIVE -> "cast(datediff(ms,?2,?3) as numeric(21))"; // return "cast(datediff(mcs,cast(?2 as bigdatetime),cast(?3 as bigdatetime)) as numeric(21))"; - default: - return "datediff(?1,?2,?3)"; - } + default -> "datediff(?1,?2,?3)"; + }; } diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseAnywhereDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseAnywhereDialect.java index eddbd5df5edf..3aa6faba5693 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseAnywhereDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseAnywhereDialect.java @@ -62,31 +62,18 @@ public SybaseAnywhereDialect(DatabaseVersion version) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case DATE: - return "date"; - case TIME: - return "time"; - case TIMESTAMP: - return "timestamp"; - case TIME_WITH_TIMEZONE: - case TIMESTAMP_WITH_TIMEZONE: - return "timestamp with time zone"; - + return switch ( sqlTypeCode ) { + case DATE -> "date"; + case TIME -> "time"; + case TIMESTAMP -> "timestamp"; + case TIME_WITH_TIMEZONE, TIMESTAMP_WITH_TIMEZONE -> "timestamp with time zone"; //these types hold up to 2 GB - case LONG32VARCHAR: - return "long varchar"; - case LONG32NVARCHAR: - return "long nvarchar"; - case LONG32VARBINARY: - return "long binary"; - - case NCLOB: - return "ntext"; - - default: - return super.columnType( sqlTypeCode ); - } + case LONG32VARCHAR -> "long varchar"; + case LONG32NVARCHAR -> "long nvarchar"; + case LONG32VARBINARY -> "long binary"; + case NCLOB -> "ntext"; + default -> super.columnType( sqlTypeCode ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TeradataDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TeradataDialect.java index fa76a017e3cd..1f836e863951 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TeradataDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TeradataDialect.java @@ -118,20 +118,14 @@ protected void registerDefaultKeywords() { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { - case BOOLEAN: - case TINYINT: - return "byteint"; + return switch ( sqlTypeCode ) { + case BOOLEAN,TINYINT -> "byteint"; //'bigint' has been there since at least version 13 - case BIGINT: - return getVersion().isBefore( 13 ) ? "numeric(19,0)" : "bigint"; - case BINARY: - return "byte($l)"; - case VARBINARY: - return "varbyte($l)"; - default: - return super.columnType( sqlTypeCode ); - } + case BIGINT -> getVersion().isBefore( 13 ) ? "numeric(19,0)" : "bigint"; + case BINARY -> "byte($l)"; + case VARBINARY -> "varbyte($l)"; + default -> super.columnType( sqlTypeCode ); + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TimesTenDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TimesTenDialect.java index 4c5123f651df..8be176c9c5fb 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TimesTenDialect.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TimesTenDialect.java @@ -82,37 +82,25 @@ public TimesTenDialect(DialectResolutionInfo info) { @Override protected String columnType(int sqlTypeCode) { - switch ( sqlTypeCode ) { + return switch ( sqlTypeCode ) { //Note: these are the correct type mappings // for the default Oracle type mode // TypeMode=0 - case SqlTypes.BOOLEAN: - case SqlTypes.TINYINT: - return "tt_tinyint"; - case SqlTypes.SMALLINT: - return "tt_smallint"; - case SqlTypes.INTEGER: - return "tt_integer"; - case SqlTypes.BIGINT: - return "tt_bigint"; + case SqlTypes.BOOLEAN, SqlTypes.TINYINT -> "tt_tinyint"; + case SqlTypes.SMALLINT -> "tt_smallint"; + case SqlTypes.INTEGER -> "tt_integer"; + case SqlTypes.BIGINT -> "tt_bigint"; //note that 'binary_float'/'binary_double' might //be better mappings for Java Float/Double //'numeric'/'decimal' are synonyms for 'number' - case SqlTypes.NUMERIC: - case SqlTypes.DECIMAL: - return "number($p,$s)"; - case SqlTypes.DATE: - return "tt_date"; - case SqlTypes.TIME: - return "tt_time"; + case SqlTypes.NUMERIC, SqlTypes.DECIMAL -> "number($p,$s)"; + case SqlTypes.DATE -> "tt_date"; + case SqlTypes.TIME -> "tt_time"; //`timestamp` has more precision than `tt_timestamp` - case SqlTypes.TIMESTAMP_WITH_TIMEZONE: - return "timestamp($p)"; - - default: - return super.columnType( sqlTypeCode ); - } + case SqlTypes.TIMESTAMP_WITH_TIMEZONE -> "timestamp($p)"; + default -> super.columnType( sqlTypeCode ); + }; } @Override @@ -193,24 +181,18 @@ protected SqlAstTranslator buildTranslator( @Override public String timestampaddPattern(TemporalUnit unit, TemporalType temporalType, IntervalType intervalType) { - switch (unit) { - case NANOSECOND: - case NATIVE: - return "timestampadd(sql_tsi_frac_second,?2,?3)"; - default: - return "timestampadd(sql_tsi_?1,?2,?3)"; - } + return switch (unit) { + case NANOSECOND, NATIVE -> "timestampadd(sql_tsi_frac_second,?2,?3)"; + default -> "timestampadd(sql_tsi_?1,?2,?3)"; + }; } @Override public String timestampdiffPattern(TemporalUnit unit, TemporalType fromTemporalType, TemporalType toTemporalType) { - switch (unit) { - case NANOSECOND: - case NATIVE: - return "timestampdiff(sql_tsi_frac_second,?2,?3)"; - default: - return "timestampdiff(sql_tsi_?1,?2,?3)"; - } + return switch (unit) { + case NANOSECOND, NATIVE -> "timestampdiff(sql_tsi_frac_second,?2,?3)"; + default -> "timestampdiff(sql_tsi_?1,?2,?3)"; + }; } @Override diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveFunction.java index 9f755ccd1d3c..cfe780c46105 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveFunction.java @@ -35,8 +35,7 @@ public void render( arrayExpression.accept( walker ); sqlAppender.append( ") AS val" ); - if ( indexExpression instanceof Literal ) { - Literal literal = (Literal) indexExpression; + if ( indexExpression instanceof Literal literal ) { Object literalValue = literal.getLiteralValue(); if ( literalValue != null ) { appendWhere( sqlAppender, walker, indexExpression ); diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveIndexFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveIndexFunction.java index 49de75cace1d..f9b24327eb27 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveIndexFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayRemoveIndexFunction.java @@ -44,8 +44,7 @@ public void render( arrayExpression.accept( walker ); sqlAppender.append( ", 1) AS idx " ); - if ( indexExpression instanceof Literal ) { - Literal literal = (Literal) indexExpression; + if ( indexExpression instanceof Literal literal ) { Object literalValue = literal.getLiteralValue(); if ( literalValue != null ) { appendWhere( sqlAppender, walker, indexExpression ); diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayReplaceFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayReplaceFunction.java index f6984df1bb63..118125f610e9 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayReplaceFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/array/GaussDBArrayReplaceFunction.java @@ -31,8 +31,7 @@ public void render( sqlAstArguments.get( 0 ).accept( walker ); sqlAppender.append( " IS NULL THEN NULL ELSE COALESCE((SELECT array_agg(CASE "); final Expression originValueExpression = (Expression) sqlAstArguments.get( 1 ); - if ( originValueExpression instanceof Literal ) { - Literal literal = (Literal) originValueExpression; + if ( originValueExpression instanceof Literal literal) { Object literalValue = literal.getLiteralValue(); if ( literalValue != null ) { sqlAppender.append( "WHEN val = "); diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAggFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAggFunction.java index a9e46b701892..af8e6c0c24b6 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAggFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAggFunction.java @@ -48,9 +48,9 @@ public void render( } final SqlAstNode firstArg = sqlAstArguments.get( 0 ); final Expression arg; - if ( firstArg instanceof Distinct ) { + if ( firstArg instanceof Distinct distinctArg) { sqlAppender.appendSql( "distinct " ); - arg = ( (Distinct) firstArg ).getExpression(); + arg = distinctArg.getExpression(); } else { arg = (Expression) firstArg; diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAppendFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAppendFunction.java index 7b455882d39f..b21dd9a7f4d5 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAppendFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayAppendFunction.java @@ -77,9 +77,8 @@ private static void buildJsonPath( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); - throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess indexParameter) { + throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + indexParameter.parameterName() + "] that is not passed" ); } else { sqlAppender.appendSql( '\'' ); diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayInsertFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayInsertFunction.java index 22cb2932947c..615e5a60261d 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayInsertFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonArrayInsertFunction.java @@ -100,8 +100,8 @@ private static void buildJsonPath( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess jsonPathElement) { + final String parameterName = jsonPathElement.parameterName(); throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); } else { diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonExistsFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonExistsFunction.java index 3051a52c477e..ecbdf0793299 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonExistsFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonExistsFunction.java @@ -48,8 +48,8 @@ protected void render( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess jsonParameterIndexAccess) { + final String parameterName = jsonParameterIndexAccess.parameterName(); throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); } else { diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonQueryFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonQueryFunction.java index 7d78dcf7d24c..6f0e9c90c16b 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonQueryFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonQueryFunction.java @@ -59,8 +59,8 @@ protected void render( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess indexParameter) { + final String parameterName = indexParameter.parameterName(); throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); } else { diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonRemoveFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonRemoveFunction.java index aad9d386badc..3c178ae871dc 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonRemoveFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonRemoveFunction.java @@ -42,8 +42,8 @@ public void render( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess indexParameter) { + final String parameterName = indexParameter.parameterName(); throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); } else { diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonSetFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonSetFunction.java index 1ef892573469..5d75e4771f82 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonSetFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonSetFunction.java @@ -47,8 +47,8 @@ public void render( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess indexParameter) { + final String parameterName = indexParameter.parameterName(); throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); } else { diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonValueFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonValueFunction.java index 5f713a4fd87d..dd08f9efb001 100644 --- a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonValueFunction.java +++ b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/json/SingleStoreJsonValueFunction.java @@ -61,8 +61,8 @@ protected void render( if ( pathElement instanceof JsonPathHelper.JsonAttribute attribute ) { sqlAppender.appendSingleQuoteEscapedString( attribute.attribute() ); } - else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess ) { - final String parameterName = ( (JsonPathHelper.JsonParameterIndexAccess) pathElement ).parameterName(); + else if ( pathElement instanceof JsonPathHelper.JsonParameterIndexAccess indexParameter) { + final String parameterName = indexParameter.parameterName(); throw new QueryException( "JSON path [" + jsonPath + "] uses parameter [" + parameterName + "] that is not passed" ); } else { diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/pagination/Oracle12LimitHandler.java b/hibernate-core/src/main/java/org/hibernate/dialect/pagination/Oracle12LimitHandler.java index 877813496b96..b372b40f4a7d 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/pagination/Oracle12LimitHandler.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/pagination/Oracle12LimitHandler.java @@ -67,18 +67,11 @@ protected String processSql(String sql, boolean hasFirstRow, boolean hasMaxRows, protected String processSql(String sql, boolean hasFirstRow, boolean hasMaxRows, int jdbcParameterCount, @Nullable ParameterMarkerStrategy parameterMarkerStrategy, LockOptions lockOptions) { if ( lockOptions != null ) { final LockMode lockMode = lockOptions.getLockMode(); - switch ( lockMode ) { - case PESSIMISTIC_READ: - case PESSIMISTIC_WRITE: - case UPGRADE_NOWAIT: - case PESSIMISTIC_FORCE_INCREMENT: - case UPGRADE_SKIPLOCKED: { - return processSql( sql, getForUpdateIndex( sql ), hasFirstRow, hasMaxRows, jdbcParameterCount, parameterMarkerStrategy ); - } - default: { - return processSqlOffsetFetch( sql, hasFirstRow, hasMaxRows, jdbcParameterCount, parameterMarkerStrategy ); - } - } + return switch ( lockMode ) { + case PESSIMISTIC_READ, PESSIMISTIC_WRITE, UPGRADE_NOWAIT, PESSIMISTIC_FORCE_INCREMENT, UPGRADE_SKIPLOCKED -> + processSql( sql, getForUpdateIndex( sql ), hasFirstRow, hasMaxRows, jdbcParameterCount, parameterMarkerStrategy ); + default -> processSqlOffsetFetch( sql, hasFirstRow, hasMaxRows, jdbcParameterCount, parameterMarkerStrategy ); + }; } return processSqlOffsetFetch( sql, hasFirstRow, hasMaxRows, jdbcParameterCount, parameterMarkerStrategy ); }