group by with map to use filter on group and calculate length fails

[AnirudhVyas]

DESCRIPTION:

 val subQuery = some_great_table
      .groupBy(_.queryId)
      .map {
        case (queryId, group) =>
          (queryId, group.filter(_.isEnabled).length, group.filter(!_.isEnabled).length)
      }

Following query should work given table :

 class SavedQueryCronDefinitionTable(tag: Tag) extends Table[SavedQueryCronDefinition](tag, "saved_query_cron_tab") {
      def * =
        (
          queryId,
          cronExpression,
          tabIdentifier,
          creation,
          startDate,
          endDate,
          niceLevel,
          executionJSON,
          isEnabled
        ) <> (SavedQueryCronDefinition.tupled, SavedQueryCronDefinition.unapply)
      def tabIdentifier: Rep[UUID]                     = column[UUID]("tab_identifier")
      def creation: Rep[LocalDateTime]                 = column[LocalDateTime]("creation")
      def startDate: Rep[Option[LocalDateTime]]        = column[Option[LocalDateTime]]("start_date")
      def endDate: Rep[Option[LocalDateTime]]          = column[Option[LocalDateTime]]("end_date")
      def niceLevel: Rep[Int]                          = column[Int]("niceness")
      def executionJSON: Rep[ExecuteSavedQueryRequest] = column[ExecuteSavedQueryRequest]("execution_json")
      def isEnabled: Rep[Boolean]                      = column[Boolean]("is_enabled")
      def pk: PrimaryKey                               = primaryKey("saved_query_current_schedule_pkey", (queryId, cronExpression))
      def queryId: Rep[String]                         = column[String]("query_id")
      def cronExpression: Rep[String]                  = column[String]("cron_expression")
    }

However when joinLeft with other tables this gives an error (even without):

slick.SlickTreeException: Cannot convert node to SQL Comprehension
| Path s5._2 : Vector[t2<{s3: String', s4: Boolean'}>]

	at slick.compiler.MergeToComprehensions.$anonfun$convert$60(MergeToComprehensions.scala:179)
	at scala.Option.getOrElse(Option.scala:189)
	at slick.compiler.MergeToComprehensions.convertBase$1(MergeToComprehensions.scala:179)
	at slick.compiler.MergeToComprehensions.$anonfun$convert$59(MergeToComprehensions.scala:173)
	at slick.compiler.MergeToComprehensions.$anonfun$convert$59$adapted(MergeToComprehensions.scala:173)
	at slick.compiler.MergeToComprehensions.mergeCommon(MergeToComprehensions.scala:356)
	at slick.compiler.MergeToComprehensions.mergeFilterWhere$1(MergeToComprehensions.scala:173)
	at slick.compiler.MergeToComprehensions.mergeGroupBy$1(MergeToComprehensions.scala:168)
	at slick.compiler.MergeToComprehensions.$anonfun$convert$36(MergeToComprehensions.scala:103)

SETUP:

slick version: 3.3.3 db: postgres sbt: 1.5.0

[AnirudhVyas]

As a side note:

  val my_great_table = TableQuery[SavedQueryCronDefinitionTable]
    my_great_table
      .map(elem => (elem.queryId, Case If elem.isEnabled Then 1 Else 0))
      .groupBy(_._1)
      .map {
        case (id, elems) => (id, elems.map(_._2).sum, elems.length - elems.map(_._2).sum)
      }
      .result
      .statements
      .foreach(println)

works. Thanks to https://github.com/sherpal for pointing out solution.

[OlegYch]

still an issue on 3.4.1