diff --git a/presto-base-jdbc/src/main/java/io/prestosql/plugin/jdbc/QueryBuilder.java b/presto-base-jdbc/src/main/java/io/prestosql/plugin/jdbc/QueryBuilder.java
index 2964e80cd801..5c4d82598c4f 100644
--- a/presto-base-jdbc/src/main/java/io/prestosql/plugin/jdbc/QueryBuilder.java
+++ b/presto-base-jdbc/src/main/java/io/prestosql/plugin/jdbc/QueryBuilder.java
@@ -23,6 +23,7 @@
 import io.prestosql.spi.predicate.Domain;
 import io.prestosql.spi.predicate.Range;
 import io.prestosql.spi.predicate.TupleDomain;
+import io.prestosql.spi.predicate.ValueSet;
 import io.prestosql.spi.type.Type;
 
 import java.sql.Connection;
@@ -34,6 +35,7 @@
 import java.util.Optional;
 import java.util.function.Function;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.base.Verify.verify;
 import static com.google.common.collect.Iterables.getOnlyElement;
@@ -199,9 +201,27 @@ private String toPredicate(JdbcColumnHandle column, Domain domain, List<TypeAndV
             return domain.isNullAllowed() ? ALWAYS_TRUE : client.quoted(column.getColumnName()) + " IS NOT NULL";
         }
 
+        String predicate = toPredicate(column, domain.getValues(), accumulator);
+        if (!domain.isNullAllowed()) {
+            return predicate;
+        }
+        return format("(%s OR %s IS NULL)", predicate, client.quoted(column.getColumnName()));
+    }
+
+    private String toPredicate(JdbcColumnHandle column, ValueSet valueSet, List<TypeAndValue> accumulator)
+    {
+        checkArgument(!valueSet.isNone(), "none values should be handled earlier");
+
+        if (!valueSet.isDiscreteSet()) {
+            ValueSet complement = valueSet.complement();
+            if (complement.isDiscreteSet()) {
+                return format("NOT (%s)", toPredicate(column, complement, accumulator));
+            }
+        }
+
         List<String> disjuncts = new ArrayList<>();
         List<Object> singleValues = new ArrayList<>();
-        for (Range range : domain.getValues().getRanges().getOrderedRanges()) {
+        for (Range range : valueSet.getRanges().getOrderedRanges()) {
             checkState(!range.isAll()); // Already checked
             if (range.isSingleValue()) {
                 singleValues.add(range.getLow().getValue());
@@ -238,7 +258,12 @@ private String toPredicate(JdbcColumnHandle column, Domain domain, List<TypeAndV
                 }
                 // If rangeConjuncts is null, then the range was ALL, which should already have been checked for
                 checkState(!rangeConjuncts.isEmpty());
-                disjuncts.add("(" + Joiner.on(" AND ").join(rangeConjuncts) + ")");
+                if (rangeConjuncts.size() == 1) {
+                    disjuncts.add(getOnlyElement(rangeConjuncts));
+                }
+                else {
+                    disjuncts.add("(" + Joiner.on(" AND ").join(rangeConjuncts) + ")");
+                }
             }
         }
 
@@ -254,12 +279,10 @@ else if (singleValues.size() > 1) {
             disjuncts.add(client.quoted(column.getColumnName()) + " IN (" + values + ")");
         }
 
-        // Add nullability disjuncts
         checkState(!disjuncts.isEmpty());
-        if (domain.isNullAllowed()) {
-            disjuncts.add(client.quoted(column.getColumnName()) + " IS NULL");
+        if (disjuncts.size() == 1) {
+            return getOnlyElement(disjuncts);
         }
-
         return "(" + Joiner.on(" OR ").join(disjuncts) + ")";
     }
 
diff --git a/presto-base-jdbc/src/test/java/io/prestosql/plugin/jdbc/TestJdbcQueryBuilder.java b/presto-base-jdbc/src/test/java/io/prestosql/plugin/jdbc/TestJdbcQueryBuilder.java
index 588136803ce6..cfd8ab19f136 100644
--- a/presto-base-jdbc/src/test/java/io/prestosql/plugin/jdbc/TestJdbcQueryBuilder.java
+++ b/presto-base-jdbc/src/test/java/io/prestosql/plugin/jdbc/TestJdbcQueryBuilder.java
@@ -47,7 +47,9 @@
 import java.util.Locale;
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.stream.LongStream;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
 import static io.airlift.slice.Slices.utf8Slice;
 import static io.airlift.testing.Assertions.assertContains;
 import static io.prestosql.plugin.jdbc.TestingJdbcTypeHandle.JDBC_BIGINT;
@@ -75,7 +77,6 @@
 import static io.prestosql.spi.type.VarcharType.VARCHAR;
 import static io.prestosql.testing.DateTimeTestingUtils.sqlTimeOf;
 import static io.prestosql.testing.DateTimeTestingUtils.sqlTimestampOf;
-import static io.prestosql.testing.TestingConnectorSession.SESSION;
 import static io.prestosql.type.DateTimes.MICROSECONDS_PER_MILLISECOND;
 import static java.lang.Float.floatToRawIntBits;
 import static java.lang.String.format;
@@ -237,16 +238,71 @@ public void testNormalBuildSql()
                 .build());
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE (\"col_0\" < ? OR (\"col_0\" >= ? AND \"col_0\" <= ?) OR \"col_0\" > ? OR \"col_0\" IN (?,?)) " +
+                    "AND ((\"col_1\" >= ? AND \"col_1\" <= ?) OR (\"col_1\" >= ? AND \"col_1\" <= ?) OR \"col_1\" IN (?,?,?,?)) " +
+                    "AND ((\"col_7\" >= ? AND \"col_7\" < ?) OR (\"col_7\" >= ? AND \"col_7\" < ?)) " +
+                    "AND ((\"col_8\" >= ? AND \"col_8\" < ?) OR (\"col_8\" >= ? AND \"col_8\" <= ?)) " +
+                    "AND (\"col_9\" < ? OR \"col_9\" IN (?,?)) " +
+                    "AND \"col_2\" = ?");
             ImmutableSet.Builder<Long> builder = ImmutableSet.builder();
-            while (resultSet.next()) {
-                builder.add((Long) resultSet.getObject("col_0"));
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    builder.add((Long) resultSet.getObject("col_0"));
+                }
             }
             assertEquals(builder.build(), ImmutableSet.of(68L, 180L, 196L));
         }
     }
 
+    /**
+     * Test query generation for domains originating from {@code NOT IN} predicates.
+     *
+     * @see Domain#complement()
+     */
+    @Test
+    public void testBuildSqlWithDomainComplement()
+            throws SQLException
+    {
+        TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.<ColumnHandle, Domain>builder()
+                // complement of a Domain with null not allowed
+                .put(columns.get(0), Domain.create(ValueSet.of(BIGINT, 128L, 180L, 233L), false).complement())
+                // complement of a Domain with null allowed
+                .put(columns.get(1), Domain.create(ValueSet.of(DOUBLE, 200011.0, 200014.0, 200017.0), true).complement())
+                // this is here only to limit the list of results being read
+                .put(columns.get(9), Domain.create(ValueSet.ofRanges(Range.greaterThanOrEqual(INTEGER, 880L)), false))
+                .build());
+
+        Connection connection = database.getConnection();
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(
+                SESSION,
+                connection,
+                TEST_TABLE,
+                Optional.empty(),
+                List.of(columns.get(0), columns.get(3), columns.get(9)),
+                tupleDomain,
+                Optional.empty(),
+                identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_3\" AS \"col_3\", \"col_9\" AS \"col_9\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE (NOT (\"col_0\" IN (?,?,?)) OR \"col_0\" IS NULL) " +
+                    "AND NOT (\"col_1\" IN (?,?,?)) " +
+                    "AND \"col_9\" >= ?");
+            ImmutableSet.Builder<Long> builder = ImmutableSet.builder();
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    builder.add((Long) resultSet.getObject("col_0"));
+                }
+            }
+            assertEquals(builder.build(), LongStream.range(980, 1000).boxed().collect(toImmutableList()));
+        }
+    }
+
     @Test
     public void testBuildSqlWithFloat()
             throws SQLException
@@ -260,13 +316,19 @@ public void testBuildSqlWithFloat()
                         false)));
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE \"col_10\" IN (?,?,?)");
             ImmutableSet.Builder<Long> longBuilder = ImmutableSet.builder();
             ImmutableSet.Builder<Float> floatBuilder = ImmutableSet.builder();
-            while (resultSet.next()) {
-                longBuilder.add((Long) resultSet.getObject("col_0"));
-                floatBuilder.add((Float) resultSet.getObject("col_10"));
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    longBuilder.add((Long) resultSet.getObject("col_0"));
+                    floatBuilder.add((Float) resultSet.getObject("col_10"));
+                }
             }
             assertEquals(longBuilder.build(), ImmutableSet.of(0L, 14L));
             assertEquals(floatBuilder.build(), ImmutableSet.of(100.0f, 114.0f));
@@ -286,11 +348,17 @@ public void testBuildSqlWithVarchar()
                         false)));
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE ((\"col_3\" >= ? AND \"col_3\" < ?) OR \"col_3\" IN (?,?))");
             ImmutableSet.Builder<String> builder = ImmutableSet.builder();
-            while (resultSet.next()) {
-                builder.add((String) resultSet.getObject("col_3"));
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    builder.add((String) resultSet.getObject("col_3"));
+                }
             }
             assertEquals(builder.build(), ImmutableSet.of("test_str_700", "test_str_701", "test_str_180", "test_str_196"));
 
@@ -314,11 +382,17 @@ public void testBuildSqlWithChar()
                         false)));
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE ((\"col_11\" >= ? AND \"col_11\" < ?) OR \"col_11\" IN (?,?))");
             ImmutableSet.Builder<String> builder = ImmutableSet.builder();
-            while (resultSet.next()) {
-                builder.add((String) resultSet.getObject("col_11"));
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    builder.add((String) resultSet.getObject("col_11"));
+                }
             }
             assertEquals(builder.build(), ImmutableSet.of("test_str_700", "test_str_701", "test_str_180", "test_str_196"));
 
@@ -347,13 +421,19 @@ public void testBuildSqlWithDateTime()
                         false)));
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE ((\"col_4\" >= ? AND \"col_4\" < ?) OR \"col_4\" IN (?,?)) AND ((\"col_5\" > ? AND \"col_5\" <= ?) OR \"col_5\" IN (?,?))");
             ImmutableSet.Builder<Date> dateBuilder = ImmutableSet.builder();
             ImmutableSet.Builder<Time> timeBuilder = ImmutableSet.builder();
-            while (resultSet.next()) {
-                dateBuilder.add((Date) resultSet.getObject("col_4"));
-                timeBuilder.add((Time) resultSet.getObject("col_5"));
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    dateBuilder.add((Date) resultSet.getObject("col_4"));
+                    timeBuilder.add((Time) resultSet.getObject("col_5"));
+                }
             }
             assertEquals(dateBuilder.build(), ImmutableSet.of(toDate(2016, 6, 7), toDate(2016, 6, 13), toDate(2016, 10, 21)));
             assertEquals(timeBuilder.build(), ImmutableSet.of(toTime(8, 23, 37), toTime(20, 23, 37)));
@@ -380,11 +460,17 @@ public void testBuildSqlWithTimestamp()
                         false)));
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE ((\"col_6\" > ? AND \"col_6\" <= ?) OR \"col_6\" IN (?,?))");
             ImmutableSet.Builder<Timestamp> builder = ImmutableSet.builder();
-            while (resultSet.next()) {
-                builder.add((Timestamp) resultSet.getObject("col_6"));
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    builder.add((Timestamp) resultSet.getObject("col_6"));
+                }
             }
             assertEquals(builder.build(), ImmutableSet.of(
                     toTimestamp(2016, 6, 3, 0, 23, 37),
@@ -404,11 +490,17 @@ public void testBuildSqlWithLimit()
     {
         Connection connection = database.getConnection();
         Function<String, String> function = sql -> sql + " LIMIT 10";
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, TupleDomain.all(), Optional.empty(), function);
-                ResultSet resultSet = preparedStatement.executeQuery()) {
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, TupleDomain.all(), Optional.empty(), function)) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "LIMIT 10");
             long count = 0;
-            while (resultSet.next()) {
-                count++;
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    count++;
+                }
             }
             assertEquals(count, 10);
         }
@@ -423,9 +515,15 @@ public void testEmptyBuildSql()
                 columns.get(1), Domain.onlyNull(DOUBLE)));
 
         Connection connection = database.getConnection();
-        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity());
-                ResultSet resultSet = preparedStatement.executeQuery()) {
-            assertEquals(resultSet.next(), false);
+        try (PreparedStatement preparedStatement = new QueryBuilder(jdbcClient).buildSql(SESSION, connection, TEST_TABLE, Optional.empty(), columns, tupleDomain, Optional.empty(), identity())) {
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_0\" AS \"col_0\", \"col_1\" AS \"col_1\", \"col_2\" AS \"col_2\", \"col_3\" AS \"col_3\", \"col_4\" AS \"col_4\", \"col_5\" AS \"col_5\", " +
+                    "\"col_6\" AS \"col_6\", \"col_7\" AS \"col_7\", \"col_8\" AS \"col_8\", \"col_9\" AS \"col_9\", \"col_10\" AS \"col_10\", \"col_11\" AS \"col_11\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE \"col_1\" IS NULL");
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                assertEquals(resultSet.next(), false);
+            }
         }
     }
 
@@ -453,11 +551,10 @@ public void testAggregation()
                 TupleDomain.all(),
                 Optional.empty(),
                 identity())) {
-            assertThat(lastQuery)
-                    .isEqualTo("" +
-                            "SELECT \"col_2\" AS \"col_2\", sum(\"col_0\") AS \"s\" " +
-                            "FROM \"test_table\" " +
-                            "GROUP BY \"col_2\"");
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_2\" AS \"col_2\", sum(\"col_0\") AS \"s\" " +
+                    "FROM \"test_table\" " +
+                    "GROUP BY \"col_2\"");
 
             try (ResultSet resultSet = preparedStatement.executeQuery()) {
                 Multiset<List<Object>> actual = read(resultSet);
@@ -496,12 +593,11 @@ public void testAggregationWithFilter()
                 tupleDomain,
                 Optional.empty(),
                 identity())) {
-            assertThat(lastQuery)
-                    .isEqualTo("" +
-                            "SELECT \"col_2\" AS \"col_2\", sum(\"col_0\") AS \"s\" " +
-                            "FROM \"test_table\" " +
-                            "WHERE ((\"col_1\" < ?) OR \"col_1\" IS NULL) " +
-                            "GROUP BY \"col_2\"");
+            assertThat(lastQuery).isEqualTo("" +
+                    "SELECT \"col_2\" AS \"col_2\", sum(\"col_0\") AS \"s\" " +
+                    "FROM \"test_table\" " +
+                    "WHERE (\"col_1\" < ? OR \"col_1\" IS NULL) " +
+                    "GROUP BY \"col_2\"");
 
             try (ResultSet resultSet = preparedStatement.executeQuery()) {
                 Multiset<List<Object>> actual = read(resultSet);
diff --git a/presto-spi/src/main/java/io/prestosql/spi/predicate/Utils.java b/presto-spi/src/main/java/io/prestosql/spi/predicate/Utils.java
index d05710b22651..7a3952aee0c7 100644
--- a/presto-spi/src/main/java/io/prestosql/spi/predicate/Utils.java
+++ b/presto-spi/src/main/java/io/prestosql/spi/predicate/Utils.java
@@ -18,6 +18,8 @@
 import io.prestosql.spi.type.Type;
 import io.prestosql.spi.type.TypeOperators;
 
+import javax.annotation.Nullable;
+
 import static io.prestosql.spi.type.TypeUtils.readNativeValue;
 import static io.prestosql.spi.type.TypeUtils.writeNativeValue;
 import static java.lang.String.format;
@@ -31,10 +33,13 @@ private Utils() {}
     // just for this use case.
     static final TypeOperators TUPLE_DOMAIN_TYPE_OPERATORS = new TypeOperators();
 
-    public static Block nativeValueToBlock(Type type, Object object)
+    public static Block nativeValueToBlock(Type type, @Nullable Object object)
     {
-        if (object != null && !Primitives.wrap(type.getJavaType()).isInstance(object)) {
-            throw new IllegalArgumentException(format("Object '%s' does not match type %s", object, type.getJavaType()));
+        if (object != null) {
+            Class<?> expectedClass = Primitives.wrap(type.getJavaType());
+            if (!expectedClass.isInstance(object)) {
+                throw new IllegalArgumentException(format("Object '%s' (%s) is not instance of %s", object, object.getClass().getName(), expectedClass.getName()));
+            }
         }
         BlockBuilder blockBuilder = type.createBlockBuilder(null, 1);
         writeNativeValue(type, blockBuilder, object);
diff --git a/presto-spi/src/main/java/io/prestosql/spi/type/TypeUtils.java b/presto-spi/src/main/java/io/prestosql/spi/type/TypeUtils.java
index 88c426182516..895c30633ba9 100644
--- a/presto-spi/src/main/java/io/prestosql/spi/type/TypeUtils.java
+++ b/presto-spi/src/main/java/io/prestosql/spi/type/TypeUtils.java
@@ -19,6 +19,8 @@
 import io.prestosql.spi.block.Block;
 import io.prestosql.spi.block.BlockBuilder;
 
+import javax.annotation.Nullable;
+
 import static io.prestosql.spi.StandardErrorCode.NOT_SUPPORTED;
 import static io.prestosql.spi.type.DoubleType.DOUBLE;
 import static io.prestosql.spi.type.RealType.REAL;
@@ -62,7 +64,7 @@ public static Object readNativeValue(Type type, Block block, int position)
     /**
      * Write a native value object to the current entry of {@code blockBuilder}.
      */
-    public static void writeNativeValue(Type type, BlockBuilder blockBuilder, Object value)
+    public static void writeNativeValue(Type type, BlockBuilder blockBuilder, @Nullable Object value)
     {
         if (value == null) {
             blockBuilder.appendNull();