diff --git a/jOOQ/src/main/java/org/jooq/tools/Convert.java b/jOOQ/src/main/java/org/jooq/tools/Convert.java
index 67928ab5ce..cfe1eee12f 100644
--- a/jOOQ/src/main/java/org/jooq/tools/Convert.java
+++ b/jOOQ/src/main/java/org/jooq/tools/Convert.java
@@ -74,6 +74,7 @@ import org.jooq.Field;
 import org.jooq.Record;
 import org.jooq.SQLDialect;
 import org.jooq.exception.DataTypeException;
+import org.jooq.tools.jdbc.MockArray;
 import org.jooq.types.UByte;
 import org.jooq.types.UInteger;
 import org.jooq.types.ULong;
@@ -415,7 +416,7 @@ public final class Convert {
             this.toClass = toClass;
         }
 
-        @SuppressWarnings("unchecked")
+        @SuppressWarnings({ "unchecked", "rawtypes" })
         @Override
         public U from(Object from) {
             if (from == null) {
@@ -459,7 +460,14 @@ public final class Convert {
                     return convert(Arrays.toString((byte[]) from), toClass);
                 }
                 else if (fromClass.isArray()) {
-                    return (U) convertArray((Object[]) from, toClass);
+
+                    // [#3443] Conversion from Object[] to JDBC Array
+                    if (toClass == java.sql.Array.class) {
+                        return (U) new MockArray(null, (Object[]) from, fromClass);
+                    }
+                    else {
+                        return (U) convertArray((Object[]) from, toClass);
+                    }
                 }
 
                 // All types can be converted into String
@@ -727,9 +735,7 @@ public final class Convert {
                 // literals to Enum values without a Converter
                 else if ((fromClass == String.class) && java.lang.Enum.class.isAssignableFrom(toClass)) {
                     try {
-                        @SuppressWarnings("rawtypes")
-                        Class raw = toClass;
-                        return (U) java.lang.Enum.valueOf(raw, (String) from);
+                        return (U) java.lang.Enum.valueOf((Class) toClass, (String) from);
                     }
                     catch (IllegalArgumentException e) {
                         return null;
@@ -781,6 +787,11 @@ public final class Convert {
                             xxxxx xxx xxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxx xxxx x x xxxxxxxxx x x xx x x xxxxxxxx xxx
                         x
                     x
+
+                    xx xxxxxxx xxxxxxxxxx xx xxxxxxxxxxx xx xxxx xxxxx
+                    xxxx xx xxxxxxxx xx xxxxxxxxxxxxxxxxxxxxx x
+                        xxxxxx xxx xxx xxxxxxxxxxxxxxx xxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+                    x
                     xxxx x
                         xxxxxx xxx xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxx
                     x
diff --git a/jOOQ/src/test/java/org/jooq/test/ConvertAllTest.java b/jOOQ/src/test/java/org/jooq/test/ConvertAllTest.java
index 1c1f0883a1..9ac6079cbc 100644
--- a/jOOQ/src/test/java/org/jooq/test/ConvertAllTest.java
+++ b/jOOQ/src/test/java/org/jooq/test/ConvertAllTest.java
@@ -41,6 +41,7 @@
 package org.jooq.test;
 
 import static org.jooq.tools.reflect.Reflect.wrapper;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
@@ -48,9 +49,12 @@ import java.lang.reflect.Array;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.sql.Date;
+import java.sql.SQLException;
 import java.sql.Time;
 import java.sql.Timestamp;
 
+import org.jooq.Record;
+import org.jooq.Result;
 import org.jooq.tools.Convert;
 
 import org.junit.Test;
@@ -304,4 +308,50 @@ public class ConvertAllTest extends AbstractTest {
         assertTrue(toArrayClass.isInstance(conv4));
         assertTrue(toArrayClass.isInstance(conv5));
     }
+
+    @Test
+    public void testToJDBCArray() throws SQLException {
+        Object[] from1 = null;
+        java.sql.Array a1 = Convert.convert(from1, java.sql.Array.class);
+        assertNull(a1);
+
+        Object[] from2 = new Object[0];
+        java.sql.Array a2 = Convert.convert(from2, java.sql.Array.class);
+        Result<Record> r2 = create.fetch(a2.getResultSet());
+        assertArrayEquals(from2, (Object[]) a2.getArray());
+        assertEquals(0, r2.size());
+        assertEquals(2, r2.fields().length);
+        assertEquals("INDEX", r2.field(0).getName());
+        assertEquals(Long.class, r2.field(0).getType());
+        assertEquals("VALUE", r2.field(1).getName());
+        assertEquals(Object.class, r2.field(1).getType());
+
+        Object[] from3 = { 1 };
+        java.sql.Array a3 = Convert.convert(from3, java.sql.Array.class);
+        Result<Record> r3 = create.fetch(a3.getResultSet());
+        assertArrayEquals(from3, (Object[]) a3.getArray());
+        assertEquals(1, r3.size());
+        assertEquals(1L, r3.getValue(0, "INDEX"));
+        assertEquals(1, r3.getValue(0, "VALUE"));
+        assertEquals(2, r3.fields().length);
+        assertEquals("INDEX", r3.field(0).getName());
+        assertEquals(Long.class, r3.field(0).getType());
+        assertEquals("VALUE", r3.field(1).getName());
+        assertEquals(Object.class, r3.field(1).getType());
+
+        String[] from4 = { "A", "B" };
+        java.sql.Array a4 = Convert.convert(from4, java.sql.Array.class);
+        Result<Record> r4 = create.fetch(a4.getResultSet());
+        assertArrayEquals(from4, (String[]) a4.getArray());
+        assertEquals(2, r4.size());
+        assertEquals(1L, r4.getValue(0, "INDEX"));
+        assertEquals("A", r4.getValue(0, "VALUE"));
+        assertEquals(2L, r4.getValue(1, "INDEX"));
+        assertEquals("B", r4.getValue(1, "VALUE"));
+        assertEquals(2, r4.fields().length);
+        assertEquals("INDEX", r4.field(0).getName());
+        assertEquals(Long.class, r4.field(0).getType());
+        assertEquals("VALUE", r4.field(1).getName());
+        assertEquals(String.class, r4.field(1).getType());
+    }
 }