Fix for Bug#82084 (23743938), YEAR DATA TYPE RETURNS INCORRECT VALUE FOR

JDBC GETCOLUMNTYPE().

Author: soklakov

CHANGES

@@ -3,6 +3,8 @@
 
 Version 8.0.29
 
+  - Fix for Bug#82084 (23743938), YEAR DATA TYPE RETURNS INCORRECT VALUE FOR JDBC GETCOLUMNTYPE().
+
   - Fix for Bug#106441 (33850155), Add charset mapping for utf8mb3.
 
   - WL#15048, Upgrade Protocol Buffers dependency to protobuf-java-3.19.4.

src/main/user-impl/java/com/mysql/cj/jdbc/DatabaseMetaData.java

@@ -37,6 +37,7 @@
 import java.sql.RowIdLifetime;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -752,6 +753,7 @@ protected enum ProcedureType {
     protected boolean tinyInt1isBit;
     protected boolean transformedBitIsBoolean;
     protected boolean useHostsInPrivileges;
+    protected boolean yearIsDateType;
 
     protected RuntimeProperty<DatabaseTerm> databaseTerm;
     protected RuntimeProperty<Boolean> nullDatabaseMeansCurrent;
@@ -792,6 +794,7 @@ protected DatabaseMetaData(JdbcConnection connToSet, String databaseToSet, Resul
         this.tinyInt1isBit = this.conn.getPropertySet().getBooleanProperty(PropertyKey.tinyInt1isBit).getValue();
         this.transformedBitIsBoolean = this.conn.getPropertySet().getBooleanProperty(PropertyKey.transformedBitIsBoolean).getValue();
         this.useHostsInPrivileges = this.conn.getPropertySet().getBooleanProperty(PropertyKey.useHostsInPrivileges).getValue();
+        this.yearIsDateType = this.conn.getPropertySet().getBooleanProperty(PropertyKey.yearIsDateType).getValue();
         this.quotedId = this.session.getIdentifierQuoteString();
     }
 
@@ -873,7 +876,8 @@ private Row convertTypeDescriptorToProcedureRow(byte[] procNameAsBytes, byte[] p
         row[2] = procNameAsBytes;                                                                                   // PROCEDURE/NAME
         row[3] = s2b(paramName);                                                                                    // COLUMN_NAME
         row[4] = s2b(String.valueOf(getColumnType(isOutParam, isInParam, isReturnParam, forGetFunctionColumns)));   // COLUMN_TYPE
-        row[5] = s2b(Short.toString((short) typeDesc.mysqlType.getJdbcType()));                                     // DATA_TYPE
+        row[5] = Short.toString(typeDesc.mysqlType == MysqlType.YEAR && !DatabaseMetaData.this.yearIsDateType ?     //
+                Types.SMALLINT : (short) typeDesc.mysqlType.getJdbcType()).getBytes();                              // DATA_TYPE (jdbc)
         row[6] = s2b(typeDesc.mysqlType.getName());                                                                 // TYPE_NAME
         row[7] = typeDesc.datetimePrecision == null ? s2b(typeDesc.columnSize.toString()) : s2b(typeDesc.datetimePrecision.toString());            // PRECISION
         row[8] = typeDesc.columnSize == null ? null : s2b(typeDesc.columnSize.toString());                          // LENGTH
@@ -1346,7 +1350,8 @@ void forEach(String dbStr) throws SQLException {
                                     }
 
                                     MysqlType ft = MysqlType.getByName(type.toUpperCase());
-                                    rowVal[2] = s2b(String.valueOf(ft.getJdbcType()));
+                                    rowVal[2] = s2b(
+                                            String.valueOf(ft == MysqlType.YEAR && !DatabaseMetaData.this.yearIsDateType ? Types.SMALLINT : ft.getJdbcType()));
                                     rowVal[3] = s2b(type);
                                     rowVal[4] = hasLength ? Integer.toString(size + decimals).getBytes() : Long.toString(ft.getPrecision()).getBytes();
                                     rowVal[5] = Integer.toString(maxBufferSize).getBytes();
@@ -2171,7 +2176,8 @@ void forEach(String dbStr) throws SQLException {
                                 rowVal[1] = DatabaseMetaData.this.databaseTerm.getValue() == DatabaseTerm.SCHEMA ? s2b(dbStr) : null;          // TABLE_SCHEM
                                 rowVal[2] = s2b(tableName);                     // TABLE_NAME
                                 rowVal[3] = results.getBytes("Field");
-                                rowVal[4] = Short.toString((short) typeDesc.mysqlType.getJdbcType()).getBytes();// DATA_TYPE (jdbc)
+                                rowVal[4] = Short.toString(typeDesc.mysqlType == MysqlType.YEAR && !DatabaseMetaData.this.yearIsDateType ? Types.SMALLINT
+                                        : (short) typeDesc.mysqlType.getJdbcType()).getBytes();  // DATA_TYPE (jdbc)
                                 rowVal[5] = s2b(typeDesc.mysqlType.getName());  // TYPE_NAME (native)
                                 if (typeDesc.columnSize == null) {              // COLUMN_SIZE
                                     rowVal[6] = null;
@@ -3943,7 +3949,7 @@ private byte[][] getTypeInfo(String mysqlTypeName) throws SQLException {
         byte[][] rowVal = new byte[18][];
 
         rowVal[0] = s2b(mysqlTypeName);                                                     // Type name
-        rowVal[1] = Integer.toString(mt.getJdbcType()).getBytes();                          // JDBC Data type
+        rowVal[1] = Integer.toString(mt == MysqlType.YEAR && !DatabaseMetaData.this.yearIsDateType ? Types.SMALLINT : mt.getJdbcType()).getBytes();                          // JDBC Data type
         // JDBC spec reserved only 'int' type for precision, thus we need to cut longer values
         rowVal[2] = Integer.toString(mt.getPrecision() > Integer.MAX_VALUE ? Integer.MAX_VALUE : mt.getPrecision().intValue()).getBytes(); // Precision
         switch (mt) {
@@ -4208,7 +4214,8 @@ void forEach(String dbStr) throws SQLException {
                                 byte[][] rowVal = new byte[8][];
                                 rowVal[0] = null;                                                                           // SCOPE is not used
                                 rowVal[1] = results.getBytes("Field");                                                      // COLUMN_NAME
-                                rowVal[2] = Short.toString((short) typeDesc.mysqlType.getJdbcType()).getBytes();            // DATA_TYPE
+                                rowVal[2] = Short.toString(typeDesc.mysqlType == MysqlType.YEAR && !DatabaseMetaData.this.yearIsDateType ? Types.SMALLINT
+                                        : (short) typeDesc.mysqlType.getJdbcType()).getBytes();                             // DATA_TYPE (jdbc)
                                 rowVal[3] = s2b(typeDesc.mysqlType.getName());                                              // TYPE_NAME
                                 rowVal[4] = typeDesc.columnSize == null ? null : s2b(typeDesc.columnSize.toString());       // COLUMN_SIZE
                                 rowVal[5] = s2b(Integer.toString(typeDesc.bufferLength));                                   // BUFFER_LENGTH

src/main/user-impl/java/com/mysql/cj/jdbc/DatabaseMetaDataUsingInfoSchema.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2005, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify it under
  * the terms of the GNU General Public License, version 2.0, as published by the
@@ -32,6 +32,7 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -1233,7 +1234,9 @@ private final void appendJdbcTypeMappingQuery(StringBuilder buf, String mysqlTyp
                         buf.append(mysqlType.getJdbcType());
                     }
                     break;
-
+                case YEAR:
+                    buf.append(this.yearIsDateType ? mysqlType.getJdbcType() : Types.SMALLINT);
+                    break;
                 default:
                     buf.append(mysqlType.getJdbcType());
             }

src/main/user-impl/java/com/mysql/cj/jdbc/result/ResultSetMetaData.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2002, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify it under
  * the terms of the GNU General Public License, version 2.0, as published by the
@@ -30,6 +30,7 @@
 package com.mysql.cj.jdbc.result;
 
 import java.sql.SQLException;
+import java.sql.Types;
 
 import com.mysql.cj.Messages;
 import com.mysql.cj.MysqlType;
@@ -185,7 +186,11 @@ public String getColumnName(int column) throws SQLException {
 
     @Override
     public int getColumnType(int column) throws SQLException {
-        return getField(column).getJavaType();
+        Field f = getField(column);
+        if (f.getMysqlType() == MysqlType.YEAR && !this.treatYearAsDate) {
+            return Types.SMALLINT;
+        }
+        return f.getJavaType();
     }
 
     @Override

src/test/java/testsuite/regression/ConnectionRegressionTest.java

@@ -6560,7 +6560,7 @@ public void testBug75592() throws Exception {
             this.rs = con.createStatement().executeQuery("SHOW VARIABLES");
             while (this.rs.next()) {
                 String val = this.rs.getString(2);
-                serverVariables.put(this.rs.getString(1), "utf8mb3".equals(val) ? "utf8" : val);
+                serverVariables.put(this.rs.getString(1), val);
             }
 
             // fix the renaming of "tx_isolation" to "transaction_isolation" that is made in NativeSession.loadServerVariables().

src/test/java/testsuite/regression/MetaDataRegressionTest.java

@@ -67,6 +67,7 @@
 import com.mysql.cj.CharsetMappingWrapper;
 import com.mysql.cj.Constants;
 import com.mysql.cj.MysqlConnection;
+import com.mysql.cj.MysqlType;
 import com.mysql.cj.NativeCharsetSettings;
 import com.mysql.cj.Query;
 import com.mysql.cj.conf.PropertyDefinitions.DatabaseTerm;
@@ -3987,7 +3988,7 @@ public void testBug35115() throws Exception {
         rsMetaData = this.rs.getMetaData();
 
         assertTrue(this.rs.next());
-        assertEquals(Types.DATE, rsMetaData.getColumnType(1), "YEAR columns should be treated as java.sql.Types.DATE");
+        assertEquals(Types.SMALLINT, rsMetaData.getColumnType(1), "YEAR columns should be treated as java.sql.Types.SMALLINT");
         assertEquals("YEAR", rsMetaData.getColumnTypeName(1), "YEAR columns should be identified as 'YEAR'");
         assertEquals(java.lang.Short.class.getName(), rsMetaData.getColumnClassName(1), "YEAR columns should be mapped to java.lang.Short");
         assertEquals(java.lang.Short.class.getName(), this.rs.getObject(1).getClass().getName(), "YEAR columns should be returned as java.lang.Short");
@@ -5408,4 +5409,60 @@ public void testBug33723611() throws Exception {
         DatabaseMetaData dbmd = this.conn.getMetaData();
         assertEquals(Connection.TRANSACTION_REPEATABLE_READ, dbmd.getDefaultTransactionIsolation());
     }
+
+    /**
+     * Tests fix for Bug#82084 (23743938), YEAR DATA TYPE RETURNS INCORRECT VALUE FOR JDBC GETCOLUMNTYPE().
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testBug82084() throws Exception {
+        createProcedure("testBug82084p", "(in param1 int, out result year) BEGIN select 1, ''; END");
+        createTable("testBug82084", "(col_tiny SMALLINT, col_year year, col_date date)");
+        this.stmt.executeUpdate("INSERT INTO testBug82084 VALUES(1,2006, '2006-01-01')");
+        Properties props = new Properties();
+        props.setProperty(PropertyKey.sslMode.getKeyName(), SslMode.DISABLED.name());
+        props.setProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName(), "true");
+
+        for (boolean useIS : new Boolean[] { true, false }) {
+            for (boolean yearIsDate : new Boolean[] { true, false }) {
+                props.setProperty(PropertyKey.yearIsDateType.getKeyName(), "" + yearIsDate);
+                props.setProperty(PropertyKey.useInformationSchema.getKeyName(), "" + useIS);
+                Connection con = getConnectionWithProps(props);
+
+                DatabaseMetaData dbmd = con.getMetaData();
+                this.rs = dbmd.getColumns(null, null, "testBug82084", "%year");
+                assertTrue(this.rs.next());
+                assertEquals(MysqlType.YEAR.getName(), this.rs.getString("TYPE_NAME"));
+                assertEquals(yearIsDate ? Types.DATE : Types.SMALLINT, this.rs.getInt("DATA_TYPE"));
+
+                this.rs = dbmd.getTypeInfo();
+                while (this.rs.next()) {
+                    if (this.rs.getString("TYPE_NAME").equals("YEAR")) {
+                        assertEquals(yearIsDate ? Types.DATE : Types.SMALLINT, this.rs.getInt("DATA_TYPE"));
+                        break;
+                    }
+                }
+
+                ResultSet procMD = con.getMetaData().getProcedureColumns(null, null, "testBug82084p", "%result");
+                assertTrue(procMD.next());
+                assertEquals(MysqlType.YEAR.getName(), procMD.getString("TYPE_NAME"));
+                assertEquals(yearIsDate ? Types.DATE : Types.SMALLINT, procMD.getInt("DATA_TYPE"));
+
+                this.rs = con.createStatement().executeQuery("select * from testBug82084");
+                ResultSetMetaData rsmd = this.rs.getMetaData();
+
+                assertEquals(MysqlType.YEAR.getName(), rsmd.getColumnTypeName(2));
+                if (yearIsDate) {
+                    assertEquals(Types.DATE, rsmd.getColumnType(2));
+                    assertEquals(java.sql.Date.class.getName(), rsmd.getColumnClassName(2));
+                } else {
+                    assertEquals(Types.SMALLINT, rsmd.getColumnType(2));
+                    assertEquals(Short.class.getName(), rsmd.getColumnClassName(2));
+                }
+
+                con.close();
+            }
+        }
+    }
 }