project compiles for 2.13

core/jvm/src/main/scala/zio/sql/Sql.scala

@@ -61,5 +61,5 @@ trait Sql {
  },
  someA => Right(someA)
  )
- implicit val none: Schema[None.type] = Schema.singleton(None)
+  implicit val none: Schema[None.type] = Schema.singleton(None)
 }

core/jvm/src/main/scala/zio/sql/expr/AggregationDef.scala

@@ -2,6 +2,7 @@ package zio.sql.expr
 
 import zio.sql.typetag.TypeTag
 import zio.sql.Features
+import java.math.BigDecimal
 
 final case class AggregationDef[-A, +B](name: FunctionName) { self =>
 

core/jvm/src/main/scala/zio/sql/table/Table.scala

@@ -192,8 +192,5 @@ object Table {
  override type TableType = A
  }
 
- trait TableEx[A]
-
- type TableExtension[A] <: Table.TableEx[A]
-
+ trait TableExtension[A]
 }

core/jvm/src/main/scala/zio/sql/typetag/Decodable.scala

@@ -5,8 +5,4 @@ import zio.sql.select.DecodingError
 
 trait Decodable[+A] {
  def decode(column: Int, resultSet: ResultSet): Either[DecodingError, A]
-}
-
-object Decodable {
- type TypeTagExtension[+A] <: Tag[A] with Decodable[A]
 }

core/jvm/src/main/scala/zio/sql/typetag/TypeTag.scala

@@ -4,7 +4,7 @@ import java.time._
 import java.util.UUID
 import zio.Chunk
 import zio.schema._
-import zio.sql.typetag.Decodable._
+import zio.sql.typetag.Decodable
 
 trait Tag[+A] {
  private[zio] def cast(a: Any): A = a.asInstanceOf[A]
@@ -13,6 +13,9 @@ trait Tag[+A] {
 sealed trait TypeTag[+A] extends Tag[A]
 
 object TypeTag {
+
+ trait TypeTagExtension[+A] extends Tag[A] with Decodable[A]
+
  sealed trait NotNull[+A] extends TypeTag[A]
  implicit case object TBigDecimal extends NotNull[java.math.BigDecimal]
  implicit case object TBoolean extends NotNull[Boolean]

examples/src/main/scala/zio/sql/Examples.scala

@@ -4,13 +4,14 @@ import java.util.UUID
 import java.time._
 import zio.sql.postgresql.PostgresJdbcModule
 import zio.schema.DeriveSchema
+import zio.sql.expr.AggregationDef._
+import zio.sql.expr.FunctionDef._
+import zio.sql.table._
 
 object Examples extends App with PostgresJdbcModule {
- import this.AggregationDef._
- import this.FunctionDef._
- import this.OrderDetails._
- import this.Orders._
- import this.Users._
+ import Orders._
+ import Users._
+ import OrderDetails._
 
  val basicSelect =
  select(fName, lName).from(users)
@@ -173,7 +174,7 @@ object Examples extends App with PostgresJdbcModule {
 
  implicit val userSchema = DeriveSchema.gen[Users]
 
- val users = defineTable[Users]
+ val users = Table.defineTable[Users]
 
  val (userId, age, dob, fName, lName) = users.columns
  }
@@ -184,7 +185,7 @@ object Examples extends App with PostgresJdbcModule {
 
  implicit val orderSchema = DeriveSchema.gen[Orders]
 
- val orders = defineTable[Orders]
+ val orders = Table.defineTable[Orders]
 
  val (orderId, fkUserId, orderDate) = orders.columns
  }
@@ -194,7 +195,7 @@ object Examples extends App with PostgresJdbcModule {
 
  implicit val orderDetailSchema = DeriveSchema.gen[OrderDetail]
 
- val orderDetails = defineTable[OrderDetail]
+ val orderDetails = Table.defineTable[OrderDetail]
 
  val (fkOrderId, fkProductId, quantity, unitPrice) = orderDetails.columns
  }

examples/src/main/scala/zio/sql/GroupByExamples.scala

@@ -2,15 +2,16 @@ package zio.sql
 
 import zio.schema.DeriveSchema
 import zio.sql.postgresql.PostgresJdbcModule
+import zio.sql.expr.AggregationDef._
+import zio.sql.table._
 
 object GroupByExamples extends App with PostgresJdbcModule {
- import AggregationDef._
 
  case class Product(id: Int, name: String, amount: Int, price: Double)
 
  implicit val productSchema = DeriveSchema.gen[Product]
 
- val productTable = defineTable[Product]
+ val productTable = Table.defineTable[Product]
 
  val (id, name, amount, price) = productTable.columns
 

jdbc/src/main/scala/zio/sql/JdbcInternalModule.scala

@@ -3,6 +3,8 @@ package zio.sql
 import java.sql._
 import java.time.{ OffsetDateTime, OffsetTime, ZoneId, ZoneOffset }
 import zio.Chunk
+import zio.sql.select._
+import zio.sql.typetag._
 
 trait JdbcInternalModule { self: Jdbc =>
 

jdbc/src/main/scala/zio/sql/SqlDriverLiveModule.scala

@@ -6,6 +6,10 @@ import zio._
 import zio.stream.{ Stream, ZStream }
 import zio.schema.Schema
 import zio.IO
+import zio.sql.update._
+import zio.sql.select._
+import zio.sql.insert._
+import zio.sql.delete._
 
 trait SqlDriverLiveModule { self: Jdbc =>
  private[sql] trait SqlDriverCore {

jdbc/src/main/scala/zio/sql/ExprSyntaxModule.scala → jdbc/src/main/scala/zio/sql/TransactionSyntaxModule.scala

@@ -3,8 +3,12 @@ package zio.sql
 import zio._
 import zio.stream.ZStream
 import zio.schema.Schema
+import zio.sql.update._
+import zio.sql.select._
+import zio.sql.insert._
+import zio.sql.delete._
 
-trait ExprSyntaxModule { self: Jdbc =>
+trait TransactionSyntaxModule { self: Jdbc =>
  implicit final class ReadSyntax[A](self: Read[A]) {
  def run: ZStream[SqlTransaction, Exception, A] =
  ZStream.serviceWithStream(_.read(self))

jdbc/src/main/scala/zio/sql/jdbc.scala

@@ -4,8 +4,12 @@ import zio._
 import zio.stream._
 import zio.schema.Schema
 import zio.sql.macros.GroupByLike
+import zio.sql.update._
+import zio.sql.select._
+import zio.sql.insert._
+import zio.sql.delete._
 
-trait Jdbc extends zio.sql.Sql with JdbcInternalModule with SqlDriverLiveModule with ExprSyntaxModule {
+trait Jdbc extends Sql with JdbcInternalModule with SqlDriverLiveModule with TransactionSyntaxModule {
  trait SqlDriver {
  def delete(delete: Delete[_]): IO[Exception, Int]
 

mysql/src/main/scala/zio/sql/mysql/MysqlRenderModule.scala

@@ -7,28 +7,35 @@ import zio.Chunk
 import zio.schema._
 import zio.schema.StandardType._
 import zio.sql.driver.Renderer
+import zio.sql.update._
+import zio.sql.select._
+import zio.sql.insert._
+import zio.sql.delete._
+import zio.sql.expr._
+import zio.sql.table._
+import zio.sql.typetag._
 
 trait MysqlRenderModule extends MysqlSqlModule { self =>
 
- override def renderRead(read: self.Read[_]): String = {
+ override def renderRead(read: Read[_]): String = {
  implicit val render: Renderer = Renderer()
  MysqlRenderer.renderReadImpl(read)
  render.toString
  }
 
- override def renderInsert[A: Schema](insert: self.Insert[_, A]): String = {
+ override def renderInsert[A: Schema](insert: Insert[_, A]): String = {
  implicit val render: Renderer = Renderer()
  MysqlRenderer.renderInsertImpl(insert)
  render.toString
  }
 
- override def renderDelete(delete: self.Delete[_]): String = {
+ override def renderDelete(delete: Delete[_]): String = {
  implicit val render: Renderer = Renderer()
  MysqlRenderer.renderDeleteImpl(delete)
  render.toString
  }
 
- override def renderUpdate(update: self.Update[_]): String = {
+ override def renderUpdate(update: Update[_]): String = {
  implicit val render: Renderer = Renderer()
  MysqlRenderer.renderUpdateImpl(update)
  render.toString
@@ -62,7 +69,7 @@ trait MysqlRenderModule extends MysqlSqlModule { self =>
  renderWhereExpr(whereExpr)
  }
 
- def renderReadImpl(read: self.Read[_])(implicit render: Renderer): Unit =
+ def renderReadImpl(read: Read[_])(implicit render: Renderer): Unit =
  read match {
  case Read.Mapped(read, _) => renderReadImpl(read)
 
@@ -250,7 +257,7 @@ trait MysqlRenderModule extends MysqlSqlModule { self =>
  table match {
  case Table.DialectSpecificTable(_) => ???
  // The outer reference in this type test cannot be checked at run time?!
- case sourceTable: self.Table.Source =>
+ case sourceTable: Table.Source =>
  render(sourceTable.name)
  case Table.DerivedTable(read, name) =>
  render(" ( ")
@@ -273,14 +280,14 @@ trait MysqlRenderModule extends MysqlSqlModule { self =>
 
  private[zio] def quoted(name: String): String = "\"" + name + "\""
 
- private def renderExpr[A, B](expr: self.Expr[_, A, B])(implicit render: Renderer): Unit = expr match {
+ private def renderExpr[A, B](expr: Expr[_, A, B])(implicit render: Renderer): Unit = expr match {
  case Expr.Subselect(subselect) =>
  render(" (")
  renderRead(subselect)
  render(") ")
  case Expr.Source(table, column) =>
  (table, column.name) match {
- case (tableName: TableName, Some(columnName)) => render(tableName, ".", columnName)
+ case (tableName: String, Some(columnName)) => render(tableName, ".", columnName)
  case _ => ()
  }
  case Expr.Unary(base, op) =>
@@ -402,15 +409,15 @@ trait MysqlRenderModule extends MysqlSqlModule { self =>
  render(")")
  }
 
- private def renderLit[A, B](lit: self.Expr.Literal[_])(implicit render: Renderer): Unit = {
+ private def renderLit[A, B](lit: Expr.Literal[_])(implicit render: Renderer): Unit = {
  import MysqlSpecific.MysqlTypeTag._
  import TypeTag._
  lit.typeTag match {
  case TDialectSpecific(tt) =>
  tt match {
- case tt @ TYear  =>
+ case tt @ TYear =>
  render(tt.cast(lit.value))
- case _: MysqlSpecific.MysqlTypeTag[_] => ???
+ case _ => ???
  }
  case TByteArray =>
  render(
@@ -531,7 +538,7 @@ trait MysqlRenderModule extends MysqlSqlModule { self =>
  * Drops the initial Litaral(true) present at the start of every WHERE expressions by default
  * and proceeds to the rest of Expr's.
  */
- private def renderWhereExpr[A, B](expr: self.Expr[_, A, B])(implicit render: Renderer): Unit = expr match {
+ private def renderWhereExpr[A, B](expr: Expr[_, A, B])(implicit render: Renderer): Unit = expr match {
  case Expr.Literal(true) => ()
  case Expr.Binary(_, b, _) =>
  render(" WHERE ")

mysql/src/main/scala/zio/sql/mysql/MysqlSqlModule.scala

@@ -4,13 +4,14 @@ import java.time._
 import java.sql.ResultSet
 import java.util.UUID
 import zio.sql.Sql
+import zio.sql.select._ 
+import zio.sql.expr._ 
+import zio.sql.typetag._
 
 trait MysqlSqlModule extends Sql { self =>
 
- override type TypeTagExtension[+A] = MysqlSpecific.MysqlTypeTag[A]
-
  object MysqlSpecific {
- trait MysqlTypeTag[+A] extends Tag[A] with Decodable[A]
+ trait MysqlTypeTag[+A] extends TypeTag.TypeTagExtension[A]
 
  object MysqlTypeTag {
  implicit case object TYear extends MysqlTypeTag[Year] {

mysql/src/test/scala/zio/sql/mysql/CommonFunctionDefSpec.scala

@@ -8,15 +8,16 @@ import zio.sql.Jdbc
 import java.util.UUID
 import java.time.LocalDate
 import zio.schema._
+import zio.sql.expr.FunctionDef.{ CharLength => _, _ }
+import zio.sql.table._
 
 object CommonFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
- import FunctionDef.{ CharLength => _, _ }
 
  case class Customers(id: UUID, dob: LocalDate, first_name: String, last_name: String, verified: Boolean)
 
  implicit val customerSchema = DeriveSchema.gen[Customers]
 
- val customers = defineTable[Customers]
+ val customers = Table.defineTable[Customers]
 
  val (customerId, dob, fName, lName, verified) = customers.columns
 

mysql/src/test/scala/zio/sql/mysql/CustomFunctionDefSpec.scala

@@ -7,6 +7,7 @@ import java.time.{ LocalDate, LocalTime, ZoneId }
 import java.time.format.DateTimeFormatter
 import zio.sql.Jdbc
 import java.util.UUID
+import zio.sql.table._
 
 object CustomFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
 
@@ -16,7 +17,7 @@ object CustomFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
 
  implicit val customerSchema = DeriveSchema.gen[Customers]
 
- val customers = defineTable[Customers]
+ val customers = Table.defineTable[Customers]
 
  val (customerId, dob, fName, lName, verified) = customers.columns
 

mysql/src/test/scala/zio/sql/mysql/DeleteSpec.scala

@@ -6,14 +6,15 @@ import java.util.UUID
 import java.time.LocalDate
 import zio.schema.DeriveSchema
 import zio.test.TestAspect.sequential
+import zio.sql.table._
 
 object DeleteSpec extends MysqlRunnableSpec {
 
  case class Customers(id: UUID, dob: LocalDate, first_name: String, lastName: String, verified: Boolean)
 
  implicit val customerSchema = DeriveSchema.gen[Customers]
 
- val customers = defineTable[Customers]
+ val customers = Table.defineTable[Customers]
 
  val (_, _, _, lastName, verified) = customers.columns
 

mysql/src/test/scala/zio/sql/mysql/MysqlModuleSpec.scala

@@ -8,39 +8,40 @@ import zio.test._
 import zio.test.Assertion._
 import zio.test.TestAspect._
 import java.math.BigDecimal
-
+import zio.sql.table._
 import scala.language.postfixOps
+import zio.sql.expr.AggregationDef._
 
 object MysqlModuleSpec extends MysqlRunnableSpec {
 
  case class Customers(id: UUID, dob: LocalDate, first_name: String, last_name: String, verified: Boolean)
 
  implicit val customerSchema = DeriveSchema.gen[Customers]
 
- val customers = defineTable[Customers]
+ val customers = Table.defineTable[Customers]
 
  val (customerId, dob, fName, lName, verified) = customers.columns
 
  case class Orders(id: UUID, customer_id: UUID, order_date: LocalDate, deleted_at: Option[LocalDateTime])
 
  implicit val orderSchema = DeriveSchema.gen[Orders]
 
- val orders = defineTable[Orders]
+ val orders = Table.defineTable[Orders]
 
  val (orderId, fkCustomerId, orderDate, deletedAt) = orders.columns
 
  case class ProductPrice(productId: UUID, effective: LocalDate, price: BigDecimal)
  implicit val productPriceSchema = DeriveSchema.gen[ProductPrice]
 
- val productPrices = defineTableSmart[ProductPrice]
+ val productPrices = Table.defineTableSmart[ProductPrice]
 
  val (productPricesOrderId, effectiveDate, productPrice) = productPrices.columns
 
  case class OrderDetails(orderId: UUID, productId: UUID, quantity: Int, unitPrice: BigDecimal)
 
  implicit val orderDetailsSchema = DeriveSchema.gen[OrderDetails]
 
- val orderDetails = defineTableSmart[OrderDetails]
+ val orderDetails = Table.defineTableSmart[OrderDetails]
 
  val (orderDetailsOrderId, orderDetailsProductId, quantity, unitPrice) = orderDetails.columns
 
@@ -206,7 +207,6 @@ object MysqlModuleSpec extends MysqlRunnableSpec {
  * Uncomment it when aggregation function handling is fixed.
  */
  test("Can count rows") {
- import AggregationDef._
  val query = select(Count(customerId)) from customers
 
  for {