Fix for Bug#34558945, PS using setCharacterStream() fails with "Incorrect string value" if the Java program encoding is not UTF-8 after 8.0.29.

Change-Id: Ic6f0c33c312b79869263c6717b9d033cc92d5c12

Author: fjssilva

CHANGES

@@ -3,6 +3,8 @@
 
 Version 8.0.33
 
+  - Fix for Bug#34558945, PS using setCharacterStream() fails with "Incorrect string value" if the Java program encoding is not UTF-8 after 8.0.29.
+
   - Fix for Bug#109013 (Bug#34772608), useServerPrepStmts and useLocalTransactionState could cause rollback failure.
 
   - Fix for bug Bug#108643 (Bug#34652568), Commit statement not effect when two params turns on.

src/main/protocol-impl/java/com/mysql/cj/protocol/a/ReaderValueEncoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023, 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
@@ -66,20 +66,23 @@ protected byte[] readBytes(Reader reader, BindValue binding) {
             byte[] bytes;
 
             boolean useLength = this.propertySet.getBooleanProperty(PropertyKey.useStreamLengthsInPrepStmts).getValue();
-            String forcedEncoding = binding.isNational() ? null : this.propertySet.getStringProperty(PropertyKey.clobCharacterEncoding).getStringValue();
+            String clobEncoding = binding.isNational() ? null : this.propertySet.getStringProperty(PropertyKey.clobCharacterEncoding).getStringValue();
+            if (clobEncoding == null) {
+                clobEncoding = this.charEncoding.getStringValue();
+            }
 
             long scaleOrLength = binding.getScaleOrLength();
             if (useLength && (scaleOrLength != -1)) {
                 c = new char[(int) scaleOrLength];
                 int numCharsRead = Util.readFully(reader, c, (int) scaleOrLength); // blocks until all read
-                bytes = StringUtils.getBytes(new String(c, 0, numCharsRead), forcedEncoding);
+                bytes = StringUtils.getBytes(new String(c, 0, numCharsRead), clobEncoding);
             } else {
                 c = new char[4096];
                 StringBuilder buf = new StringBuilder();
                 while ((len = reader.read(c)) != -1) {
                     buf.append(c, 0, len);
                 }
-                bytes = StringUtils.getBytes(buf.toString(), forcedEncoding);
+                bytes = StringUtils.getBytes(buf.toString(), clobEncoding);
             }
             return escapeBytesIfNeeded(bytes);
 

src/test/java/testsuite/regression/StatementRegressionTest.java

@@ -13160,4 +13160,94 @@ public <T extends Resultset> T preProcess(Supplier<String> sql, Query intercepte
             return super.preProcess(sql, interceptedQuery);
         }
     }
+
+    /**
+     * Tests fix for Bug#34558945, PS using setCharacterStream() fails with "Incorrect string value" if the Java program encoding is not UTF-8 after 8.0.29.
+     * 
+     * @throws Exception
+     */
+    @Test
+    void testBug34558945() throws Exception {
+        createTable("testBug34558945Utf8", "(txt VARCHAR(100) COLLATE utf8mb4_0900_ai_ci)");
+        createTable("testBug34558945SJis", "(txt VARCHAR(100) COLLATE sjis_japanese_ci)");
+
+        Properties props = new Properties();
+        props.setProperty(PropertyKey.sslMode.getKeyName(), SslMode.DISABLED.name());
+        props.setProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName(), "true");
+
+        final String utf8 = "UTF-8";
+        final String sjis = "Shift_JIS";
+        final String[] charEncs = { null, utf8, sjis };
+        final String value = "\u7ADC";
+
+        for (String ce : charEncs) {
+            for (String cce : charEncs) {
+
+                if (ce == null) {
+                    props.remove(PropertyKey.characterEncoding.getKeyName());
+                } else {
+                    props.setProperty(PropertyKey.characterEncoding.getKeyName(), ce);
+                }
+                if (cce == null) {
+                    props.remove(PropertyKey.clobCharacterEncoding.getKeyName());
+                } else {
+                    props.setProperty(PropertyKey.clobCharacterEncoding.getKeyName(), cce);
+                }
+
+                boolean useSPS = false;
+                do {
+                    props.setProperty(PropertyKey.useServerPrepStmts.getKeyName(), Boolean.toString(useSPS));
+                    try (Connection testConn = getConnectionWithProps(props)) {
+                        int records;
+                        PreparedStatement testPStmt;
+                        Statement testStmt;
+
+                        // Table with UTF-8 column.
+                        records = 1;
+                        testPStmt = testConn.prepareStatement("INSERT INTO testBug34558945Utf8 VALUES (?)");
+                        testPStmt.setString(1, value);
+                        assertEquals(1, testPStmt.executeUpdate());
+                        testPStmt.setCharacterStream(1, new StringReader(value), value.length());
+                        if (sjis.equals(cce) || cce == null && sjis.equals(ce)) {
+                            assertThrows(SQLException.class, ".*Incorrect string value:.*", testPStmt::executeUpdate);
+                        } else {
+                            assertEquals(1, testPStmt.executeUpdate());
+                            records = 2;
+                        }
+
+                        testStmt = testConn.createStatement();
+                        this.rs = testStmt.executeQuery("SELECT * FROM testBug34558945Utf8");
+                        while (records-- > 0) {
+                            assertTrue(this.rs.next());
+                            assertEquals(value, this.rs.getString(1));
+                        }
+                        assertFalse(this.rs.next());
+                        testStmt.executeUpdate("TRUNCATE TABLE testBug34558945Utf8");
+
+                        // Table with Shift_JIS column.
+                        records = 1;
+                        testPStmt = testConn.prepareStatement("INSERT INTO testBug34558945SJis VALUES (?)");
+                        testPStmt.setString(1, value);
+                        assertEquals(1, testPStmt.executeUpdate());
+                        testPStmt.setCharacterStream(1, new StringReader(value), value.length());
+                        if (sjis.equals(cce) || cce == null && sjis.equals(ce)) {
+                            assertEquals(1, testPStmt.executeUpdate());
+                            records = 2;
+                        } else {
+                            assertThrows(SQLException.class, ".*Incorrect string value:.*", testPStmt::executeUpdate);
+                        }
+
+                        testStmt = testConn.createStatement();
+                        this.rs = testStmt.executeQuery("SELECT * FROM testBug34558945SJis");
+                        while (records-- > 0) {
+                            assertTrue(this.rs.next());
+                            assertEquals(value, this.rs.getString(1));
+                        }
+                        assertFalse(this.rs.next());
+                        testStmt.executeUpdate("TRUNCATE TABLE testBug34558945SJis");
+                    }
+                } while (useSPS = !useSPS);
+            }
+        }
+    }
 }