bulk_update throws error when setting array field to None
psycopg2 uses "%s" for all parameter placeholders, and automatically converts `None` to `NULL` so I do not believe this is the issue. To be honest this one has me stumped, as entering the following into the postgres shell also fails with the same error:

```sql
update users 
set emails = case users.id when 1 then null end
where users.id = 1
```

The issue is that postgres wants us to explicitly cast the result of `case` expression:

```sql
-- this works
update "users" set emails = cast(
  case "users"."id" when 1 then NULL end
  as character varying[])
where ("users"."id" in (1));
```

I think I'm just going to have to mark this for now as wontfix since it works fine when you specify an actual list of names. I won't go so far as to say this is a postgres bug, but it certainly feels like one as it works fine with an actual array of emails and only throws an error if you pass an (equally-valid) NULL value.

Thanks for the helpful report. I will update the issue if anything changes. Thanks for the insight. You're right. It appears to be known behavior for Postgres, see for example: https://dba.stackexchange.com/a/228058

I still think it's something where Peewee or Postgres or maybe even psycopg2 could improve the user experience. I'm just not sure where the best place to ask for an improvement is.
Here's the situation: I have a model that has an array field where `null=True`. Something like this:

```python
class User(Model):
    emails = ArrayField(CharField, null=True)
```

That's all good, but when I do this:

```python
user = User.create(emails=None) # or get it from a query, etc.

User.bulk_update([user], fields=['emails'])
```

It throws this error:

```
Traceback (most recent call last):
  File ".../peewee.py", line 3099, in execute_sql
    cursor.execute(sql, params or ())
psycopg2.errors.DatatypeMismatch: column "emails" is of type character varying[] but expression is of type text
LINE 1: ... "emails" = CASE "cont...
                                                             ^
HINT:  You will need to rewrite or cast the expression.
```

I investigated and found the SQL it generates looks like this:

```
('UPDATE "user" SET "emails" = CASE "user"."id" WHEN %s THEN %s END WHERE ("user"."id" IN (%s))', [123, None, 123])
```

I believe the issue is that the Python "None" is being cast as a string in the generated SQL via the "%s" instead of properly being converted to NULL.

Luckily the amount of rows I'm dealing with in this particular case is small so I can work around this by just saving each individually, but I can imagine other situations where it could really impact performance.