Scala 3 migration

.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        scala: [2.13.8]
+        scala: [2.13.8, 3.3.1]
         java: [temurin@17]
         clickhouse: [21.3, 21.8.14, 22.3]
     runs-on: ${{ matrix.os }}
@@ -82,7 +82,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        scala: [2.13.8]
+        scala: [2.13.13, 3.3.1]
         java: [temurin@17]
     runs-on: ${{ matrix.os }}
     steps:
@@ -110,12 +110,22 @@ jobs:
             ~/Library/Caches/Coursier/v1
           key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }}
 
-      - name: Download target directories (2.13.8)
+      - name: Download target directories (3.3.1)
         uses: actions/download-artifact@v2
         with:
-          name: target-${{ matrix.os }}-2.13.8-${{ matrix.java }}
+          name: target-${{ matrix.os }}-3.3.1-${{ matrix.java }}
 
-      - name: Inflate target directories (2.13.8)
+      - name: Inflate target directories (3.3.1)
+        run: |
+          tar xf targets.tar
+          rm targets.tar
+
+      - name: Download target directories (2.13.13)
+        uses: actions/download-artifact@v2
+        with:
+          name: target-${{ matrix.os }}-2.13.13-${{ matrix.java }}
+
+      - name: Inflate target directories (2.13.13)
         run: |
           tar xf targets.tar
           rm targets.tar

build.sbt

@@ -16,8 +16,8 @@ lazy val root = (project in file("."))
     inThisBuild(
       List(
         organization := "com.crobox.clickhouse",
-        scalaVersion := "2.13.8",
-        crossScalaVersions := List("2.13.8"),
+        scalaVersion := "2.13.13",
+        crossScalaVersions := List("2.13.13", "3.3.1"),
         javacOptions ++= Seq("-g", "-Xlint:unchecked", "-Xlint:deprecation", "-source", "11", "-target", "11"),
         scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature", "-language:_", "-encoding", "UTF-8"),
         publishTo := {

dsl/src/it/scala-2/com/crobox/clickhouse/dsl/QueryITTypeCast.scala

@@ -0,0 +1,53 @@
+package com.crobox.clickhouse.dsl
+
+import com.crobox.clickhouse.DslITSpec
+class QueryITTypeCast extends DslITSpec {
+
+  // This test uses extension methods removed in Scala 3. Hence only making it available for Scala 2
+  it should "perform typecasts" in {
+
+    type TakeIntGiveIntTypes = Column => (TypeCastColumn[T] with Reinterpretable) forSome {
+      type T >: Long with String with Float with Serializable
+    }
+
+    val takeIntGiveIntCast = Set(
+      toUInt8 _,
+      toUInt16 _,
+      toUInt32 _,
+      toUInt64 _,
+      toInt8 _,
+      toInt16 _,
+      toInt32 _,
+      toInt64 _,
+      toFloat32 _,
+      toFloat64 _
+    )
+
+    val takeIntGiveStringCast = Set(
+      toDate _,
+      toDateTime _,
+      toStringRep _
+    )
+
+    val reinterpToIntCast = takeIntGiveIntCast
+
+    val reinterpToStringCast = Set(
+      toStringRep _
+    )
+
+    val takeStringGiveIntCast = Set(
+      toUInt8OrZero _,
+      toUInt16OrZero _,
+      toUInt32OrZero _,
+      toUInt64OrZero _,
+      toInt8OrZero _,
+      toInt16OrZero _,
+      toInt32OrZero _,
+      toInt64OrZero _,
+      toFloat32OrZero _,
+      toFloat64OrZero _,
+      (col: TableColumn[_]) => toFixedString(col, 10),
+      toStringCutToZero _
+    )
+  }
+}

dsl/src/it/scala/com/crobox/clickhouse/dsl/ClickhouseTimeSeriesIT.scala

@@ -1,12 +1,13 @@
 package com.crobox.clickhouse.dsl
 
-import com.crobox.clickhouse.DslITSpec
+import com.crobox.clickhouse.{ClickhouseClient, DslITSpec}
 import com.crobox.clickhouse.dsl.execution.QueryResult
 import com.crobox.clickhouse.dsl.marshalling.ClickhouseJsonSupport._
 import com.crobox.clickhouse.time.{IntervalStart, MultiDuration, MultiInterval, TimeUnit, TotalDuration}
 import org.joda.time.{DateTime, DateTimeZone, Days}
 import org.scalactic.TripleEqualsSupport
 import org.scalatest.prop.TableDrivenPropertyChecks
+import spray.json.RootJsonFormat
 
 import java.util.UUID
 import scala.concurrent.Future
@@ -17,10 +18,10 @@ class ClickhouseTimeSeriesIT extends DslITSpec with TableDrivenPropertyChecks {
   case class CustomResult(time: IntervalStart, shields: String)
 
   object CustomResult {
-    implicit val format = jsonFormat2(CustomResult.apply)
+    implicit val format: RootJsonFormat[CustomResult] = jsonFormat2(CustomResult.apply)
   }
 
-  implicit val clickhouseClient                   = clickClient
+  implicit val clickhouseClient: ClickhouseClient = clickClient
   val startInterval                               = DateTime.parse("2019-03-01").withTimeAtStartOfDay().withZone(DateTimeZone.UTC)
   val secondsId                                   = UUID.randomUUID()
   val dayId                                       = UUID.randomUUID()

dsl/src/it/scala/com/crobox/clickhouse/dsl/QueryIT.scala

@@ -30,53 +30,6 @@ class QueryIT extends DslITSpec {
     results.futureValue.rows.map(_.empty).head should be(1)
   }
 
-  it should "perform typecasts" in {
-
-    type TakeIntGiveIntTypes = Column => (TypeCastColumn[_$1] with Reinterpretable) forSome {
-      type _$1 >: Long with String with Float with Serializable
-    }
-
-    val takeIntGiveIntCast = Set(
-      toUInt8 _,
-      toUInt16 _,
-      toUInt32 _,
-      toUInt64 _,
-      toInt8 _,
-      toInt16 _,
-      toInt32 _,
-      toInt64 _,
-      toFloat32 _,
-      toFloat64 _
-    )
-
-    val takeIntGiveStringCast = Set(
-      toDate _,
-      toDateTime _,
-      toStringRep _
-    )
-
-    val reinterpToIntCast = takeIntGiveIntCast
-
-    val reinterpToStringCast = Set(
-      toStringRep _
-    )
-
-    val takeStringGiveIntCast = Set(
-      toUInt8OrZero _,
-      toUInt16OrZero _,
-      toUInt32OrZero _,
-      toUInt64OrZero _,
-      toInt8OrZero _,
-      toInt16OrZero _,
-      toInt32OrZero _,
-      toInt64OrZero _,
-      toFloat32OrZero _,
-      toFloat64OrZero _,
-      (col: TableColumn[_]) => toFixedString(col, 10),
-      toStringCutToZero _
-    )
-  }
-
   def runQry(query: OperationalQuery): Future[String] = {
     val che = queryExecutor.asInstanceOf[DefaultClickhouseQueryExecutor]
     clickhouseClient.query(che.toSql(query.internalQuery))

dsl/src/it/scala/com/crobox/clickhouse/dsl/column/ComparisonFunctionsIT.scala

@@ -13,8 +13,6 @@ class ComparisonFunctionsIT extends DslITSpec {
     r(someNum >= 3) shouldBe "1"
     r(someNum <= 3) shouldBe "0"
     r(someNum isEq 3) shouldBe "0"
-    r(someNum === 3) shouldBe "0"
-    r(someNum !== 3) shouldBe "1"
     r(notEquals(1,2)) shouldBe "1"
     r(_equals(2L,2)) shouldBe "1"
     r(less(1.0,200)) shouldBe "1"

dsl/src/it/scala/com/crobox/clickhouse/dsl/column/INFunctionsIT.scala

@@ -3,6 +3,8 @@ package com.crobox.clickhouse.dsl.column
 import com.crobox.clickhouse.DslITSpec
 import com.crobox.clickhouse.dsl.misc.LogicalOperatorImprovements.ExpressionColumnImpr
 import com.crobox.clickhouse.dsl.select
+import com.crobox.clickhouse.dsl._
+import scala.language.implicitConversions
 
 import java.util.UUID
 
@@ -21,9 +23,15 @@ class INFunctionsIT extends DslITSpec {
       Table3Entry(UUID.randomUUID(), 2, Option("b"), "c", "c")
     )
 
+  // TODO: Temporary Scala 3 Workaround. Somehow in CI/CD version of Scala 3, columns are not converted to respectible
+  // Magnet instances, so that `in` method could be used. Need to explicitly specify type annotation for conversion to
+  // work. This may require more deep work on this in the future
+  private val constCol4: ConstOrColMagnet[String] = col4
+  private val constCol2: ConstOrColMagnet[Int] = col2
+
   it should "use tableAlias for IN, single table" in {
     execute(
-      select(col4).from(TwoTestTable).where(col4.in(select(col4).from(ThreeTestTable)))
+      select(col4).from(TwoTestTable).where(constCol4.in(select(col4).from(ThreeTestTable)))
     ).futureValue should be("a\nb")
   }
 
@@ -35,9 +43,9 @@ class INFunctionsIT extends DslITSpec {
       select(col4)
         .from(TwoTestTable)
         .where(
-          col4.in(select(col4).from(ThreeTestTable)) and
-          col2.in(select(col2).from(TwoTestTable)) and
-          col2.in(select(col4).from(ThreeTestTable))
+          constCol4.in(select(col4).from(ThreeTestTable)) and
+            constCol2.in(select(col2).from(TwoTestTable)) and
+            constCol2.in(select(col4).from(ThreeTestTable))
         )
     ).futureValue should be("")
   }

dsl/src/it/scala/com/crobox/clickhouse/dsl/column/NumericColFunctionIT.scala

@@ -40,8 +40,8 @@ class NumericColFunctionIT extends DslITSpec {
   it should "have correct types so reduce can be used" in {
     val exp = Seq(
       Const(true),
-      2 === 2,
-      3 === 3
+      2 isEq 2,
+      3 isEq 3
     ).reduce(_ or _)
 
     toSql(

dsl/src/main/scala/com/crobox/clickhouse/dsl/JoinQuery.scala

@@ -58,7 +58,7 @@ object JoinQuery {
 case class JoinQuery(joinType: JoinType,
                      other: FromQuery,
                      on: Seq[JoinCondition] = Seq.empty,
-                     using: Seq[Column] = Seq.empty,
+                     `using`: Seq[Column] = Seq.empty,
                      global: Boolean = false)
 
 case class JoinCondition(left: Column, operator: String, right: Column) {

dsl/src/main/scala/com/crobox/clickhouse/dsl/OperationalQuery.scala

@@ -36,7 +36,7 @@ trait OperationalQuery extends Query {
     OperationalQuery(
       internalQuery.from
         .map {
-          case query: InnerFromQuery    => internalQuery.copy(from = Some(query.copy(alias = Option(alias))))
+          case query: InnerFromQuery => internalQuery.copy(from = Some(query.copy(alias = Option(alias))))
           case table: TableFromQuery[_] => internalQuery.copy(from = Some(table.copy(alias = Option(alias))))
         }
         .getOrElse(internalQuery)
@@ -72,8 +72,8 @@ trait OperationalQuery extends Query {
 
   def groupBy(columns: Column*): OperationalQuery = {
     val internalGroupBy = internalQuery.groupBy.getOrElse(GroupByQuery())
-    val newGroupBy      = Some(internalGroupBy.copy(usingColumns = internalGroupBy.usingColumns ++ columns))
-    val newSelect       = mergeOperationalColumns(columns)
+    val newGroupBy = Some(internalGroupBy.copy(usingColumns = internalGroupBy.usingColumns ++ columns))
+    val newSelect = mergeOperationalColumns(columns)
     OperationalQuery(
       internalQuery.copy(select = newSelect, groupBy = newGroupBy)
     )
@@ -122,7 +122,7 @@ trait OperationalQuery extends Query {
 
   def unionAll(otherQuery: OperationalQuery): OperationalQuery = {
     require(internalQuery.select.isDefined && otherQuery.internalQuery.select.isDefined,
-            "Trying to apply UNION ALL on non SELECT queries.")
+      "Trying to apply UNION ALL on non SELECT queries.")
     require(
       otherQuery.internalQuery.select.get.columns.size == internalQuery.select.get.columns.size,
       "SELECT queries needs to have the same number of columns to perform UNION ALL."
@@ -146,7 +146,7 @@ trait OperationalQuery extends Query {
     val filteredDuplicates = filteredSelectAll.filterNot(column => {
       selectForGroupCols.exists {
         case c: Column => column.name == c.name
-        case _         => false
+        case _ => false
       }
     })
 
@@ -225,12 +225,12 @@ trait OperationalQuery extends Query {
     globalJoin(JoinQuery.AnyRightJoin, query)
 
   def using(
-      column: Column,
-      columns: Column*
-  ): OperationalQuery = {
+             column: Column,
+             columns: Column*
+           ): OperationalQuery = {
     require(internalQuery.join.isDefined)
 
-    val newJoin = this.internalQuery.join.get.copy(using = (column +: columns).distinct)
+    val newJoin = this.internalQuery.join.get.copy(`using` = (column +: columns).distinct)
     OperationalQuery(internalQuery.copy(join = Some(newJoin)))
   }
 

dsl/src/main/scala/com/crobox/clickhouse/dsl/Query.scala

@@ -3,7 +3,7 @@ package com.crobox.clickhouse.dsl
 import scala.util.Try
 
 trait Table {
-  val database: String
+  def database: String = ""
   val name: String
   lazy val quoted: String =
     s"${ClickhouseStatement.quoteIdentifier(database)}.${ClickhouseStatement.quoteIdentifier(name)}"

dsl/src/main/scala/com/crobox/clickhouse/dsl/column/ArithmeticFunctions.scala

@@ -2,6 +2,7 @@ package com.crobox.clickhouse.dsl.column
 
 import com.crobox.clickhouse.dsl.{EmptyColumn, ExpressionColumn, TableColumn}
 import org.joda.time.{DateTime, LocalDate}
+import scala.language.implicitConversions
 
 trait ArithmeticFunctions { self: Magnets =>
 

dsl/src/main/scala/com/crobox/clickhouse/dsl/column/ComparisonFunctions.scala

@@ -2,26 +2,20 @@ package com.crobox.clickhouse.dsl.column
 
 import com.crobox.clickhouse.dsl.{EmptyColumn, ExpressionColumn}
 
-trait ComparisonFunctions { self: Magnets =>
+trait ComparisonFunctions {
+  self: Magnets =>
 
   case class ComparisonColumn(left: Magnet[_], operator: String, right: Magnet[_]) extends ExpressionColumn[Boolean](EmptyColumn)
 
-  trait ComparableWith[M <: Magnet[_]] { self: Magnet[_] =>
-    def <(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "<", other)
-    def >(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, ">", other)
-    def <>(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "!=", other)
-    def isEq(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "=", other)
-    def notEq(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "!=", other)
-    def ===(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "=", other)
-    def !==(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "!=", other)
-    def <=(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, "<=", other)
-    def >=(other: M): ExpressionColumn[Boolean] = ComparisonColumn(self, ">=", other)
-  }
-
-  def _equals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1 , "=", col2)
-  def notEquals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1 , "!=", col2)
-  def less(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1 , "<", col2)
-  def greater(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1 , ">", col2)
-  def lessOrEquals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1 , "<=", col2)
-  def greaterOrEquals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1 , ">=", col2)
+  def _equals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1, "=", col2)
+
+  def notEquals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1, "!=", col2)
+
+  def less(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1, "<", col2)
+
+  def greater(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1, ">", col2)
+
+  def lessOrEquals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1, "<=", col2)
+
+  def greaterOrEquals(col1: ConstOrColMagnet[_], col2: ConstOrColMagnet[_]): ExpressionColumn[Boolean] = ComparisonColumn(col1, ">=", col2)
 }

dsl/src/main/scala/com/crobox/clickhouse/dsl/column/InFunctions.scala

@@ -1,6 +1,7 @@
 package com.crobox.clickhouse.dsl.column
 
 import com.crobox.clickhouse.dsl.{Const, EmptyColumn, ExpressionColumn}
+import com.crobox.clickhouse.dsl.marshalling.QueryValueFormats._
 
 trait InFunctions { self: Magnets =>