Merge pull request zio-archive#830 from sviezypan/core_refactor

Refactoring of core module

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

@@ -1,19 +1,13 @@
 package zio.sql
 
 import zio.schema.Schema
+import zio.sql.table._
+import zio.sql.update._
+import zio.sql.select._
+import zio.sql.insert._
+import zio.sql.delete._
 
-trait Sql
-    extends SelectModule
-    with DeleteModule
-    with UpdateModule
-    with ExprModule
-    with TableModule
-    with AllColumnsModule
-    with InsertModule
-    with UtilsModule
-    with SelectUtilsModule
-    with InsertUtilsModule {
-  self =>
+trait Sql {
 
   /*
    * (SELECT *, "foo", table.a + table.b AS sum... FROM table WHERE cond) UNION (SELECT ... FROM table)
@@ -48,13 +42,24 @@ trait Sql
 
   def insertInto[Source, AllColumnIdentities](
     table: Table.Source.Aux_[Source, AllColumnIdentities]
-  ): InsertIntoBuilder[Source, AllColumnIdentities] = InsertIntoBuilder(table)
+  ): InsertByCommaBuilder[Source, AllColumnIdentities] = InsertByCommaBuilder(table)
 
-  def renderDelete(delete: self.Delete[_]): String
+  def renderDelete(delete: Delete[_]): String
 
-  def renderRead(read: self.Read[_]): String
+  def renderRead(read: Read[_]): String
 
-  def renderUpdate(update: self.Update[_]): String
+  def renderUpdate(update: Update[_]): String
 
-  def renderInsert[A: Schema](insert: self.Insert[_, A]): String
+  def renderInsert[A: Schema](insert: Insert[_, A]): String
+
+  // TODO don't know where to put it now
+  implicit def convertOptionToSome[A](implicit op: Schema[Option[A]]): Schema[Some[A]] =
+    op.transformOrFail[Some[A]](
+      {
+        case Some(a) => Right(Some(a))
+        case None    => Left("cannot encode Right")
+      },
+      someA => Right(someA)
+    )
+  implicit val none: Schema[None.type]                                                 = Schema.singleton(None)
 }

core/jvm/src/main/scala/zio/sql/delete/Delete.scala

@@ -0,0 +1,8 @@
+package zio.sql.delete
+
+import zio.sql.table._
+import zio.sql.expr.Expr
+
+final case class Delete[A](table: Table.Aux[A], whereExpr: Expr[_, A, Boolean]) {
+  def where[F](expr: Expr[F, A, Boolean]): Delete[A] = Delete(table, expr)
+}