How to use `ConstColumn` for optional values in the Slick - scala

Question

There is some table:
case class Thing(name: String, color: Option[String], height: Option[String])
class ThingSchema(t: Tag) extends Table[Thing](t, "things") {
def name = column[String]("name")
def color = column[Option[String]]("color")
def height = column[Option[String]]("height")
def * = (name, color, height) <> (Thing.tupled, Thing.unapply)
}
val things = TableQuery[ThingSchema]
For example, there are the following data in the things table:
| name | color | height |
+---------+-----------+--------+
| n1 | green | <null> |
| n1 | green | <null> |
| n1 | <null> | normal |
| n1 | <null> | normal |
| n1 | red | <null> |
| n2 | red | <null> |
I need to get the following result from the above data:
| name | color | height | size |
+---------+-----------+--------+------+
| n1 | green | <null> | 2 |
| n1 | <null> | normal | 2 |
| n1 | red | <null> | 1 |
| n2 | red | <null> | 1 |
To solve this task I use the following grouping queries:
SELECT name, color, null, count(*) AS size
FROM things
GROUP BY name, color
UNION ALL
SELECT name, null, height, count(*) AS size
FROM things
GROUP BY name, height
I've tried to create this query with the Slick:
val query1 =
things.groupBy(t => (t.name, t.color))
.map { case ((name, color), g) => (name,color,None, g.size)} //Error#1
val query2 =
things.groupBy(t => (t.name, t.height))
.map { case ((name, height), g) => (name,None,height,g.size)} //Error#1
val query = query1 ++ query2
But the above code isn't compiled, because the Slick can't define type for ConstColumn for the None values (see //Error#1 comment in the above code).
This would work for the NOT-null values (such as numbers, strings), but doesn't work for Nullable values which are represented as Option[String]=None for example.
How to use ConstColumn for None values for this case?
Here is the link to the same question

Answer 1

I've found another solution for this task. Perhaps it will be useful for someone.
We can use Rep.None[T] or Rep.Some[T] to generate ConstColumn values for optional types.
This example works too:
val query1 =
things.groupBy(t => (t.name, t.color))
.map { case ((name, color), g) =>
(name,color, Rep.None[String], g.size)
}
This approach has two advantages:
1) We can assign to more general type. For example:
val field: Rep[String] = ...
val x: (Rep[String], Rep[Option[String]]) = (field, Rep.None[String])
// it is not compiled because a tuple has type (Rep[String], Option[String])
val y: (Rep[String], Rep[Option[String]]) = (field, None: Option[String])
2) This approach is a bit shorter

Answer 2

The error I'd expect in this situation is a type-mismatch of some kind between Option[String] and None.type at the two //Error points in your code.
What you can do is give a type annotation on the None:
val query1 =
things.groupBy(t => (t.name, t.color))
.map { case ((name, color), g) => (name,color, None: Option[String], g.size)}
That will be compiled into the SELECT name, color, null, count pattern you're using.