Upgrade Doobie to 1.0.0-RC9 (fixes #141)

.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/compositepk/person/PersonRepoImpl.scala

@@ -32,24 +32,24 @@ class PersonRepoImpl extends PersonRepo {
     DeleteBuilder(""""compositepk"."person"""", PersonFields.structure)
   }
   override def deleteById(compositeId: PersonId): ConnectionIO[Boolean] = {
-    sql"""delete from "compositepk"."person" where "one" = ${fromWrite(compositeId.one)(Write.fromPut(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(Write.fromPutOption(Meta.StringMeta.put))}""".update.run.map(_ > 0)
+    sql"""delete from "compositepk"."person" where "one" = ${fromWrite(compositeId.one)(new Write.Single(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(new Write.SingleOpt(Meta.StringMeta.put))}""".update.run.map(_ > 0)
   }
   override def insert(unsaved: PersonRow): ConnectionIO[PersonRow] = {
     sql"""insert into "compositepk"."person"("one", "two", "name")
-          values (${fromWrite(unsaved.one)(Write.fromPut(Meta.LongMeta.put))}::int8, ${fromWrite(unsaved.two)(Write.fromPutOption(Meta.StringMeta.put))}, ${fromWrite(unsaved.name)(Write.fromPutOption(Meta.StringMeta.put))})
+          values (${fromWrite(unsaved.one)(new Write.Single(Meta.LongMeta.put))}::int8, ${fromWrite(unsaved.two)(new Write.SingleOpt(Meta.StringMeta.put))}, ${fromWrite(unsaved.name)(new Write.SingleOpt(Meta.StringMeta.put))})
           returning "one", "two", "name"
        """.query(using PersonRow.read).unique
   }
   override def insert(unsaved: PersonRowUnsaved): ConnectionIO[PersonRow] = {
     val fs = List(
-      Some((Fragment.const0(s""""name""""), fr"${fromWrite(unsaved.name)(Write.fromPutOption(Meta.StringMeta.put))}")),
+      Some((Fragment.const0(s""""name""""), fr"${fromWrite(unsaved.name)(new Write.SingleOpt(Meta.StringMeta.put))}")),
       unsaved.one match {
         case Defaulted.UseDefault => None
-        case Defaulted.Provided(value) => Some((Fragment.const0(s""""one""""), fr"${fromWrite(value: Long)(Write.fromPut(Meta.LongMeta.put))}::int8"))
+        case Defaulted.Provided(value) => Some((Fragment.const0(s""""one""""), fr"${fromWrite(value: Long)(new Write.Single(Meta.LongMeta.put))}::int8"))
       },
       unsaved.two match {
         case Defaulted.UseDefault => None
-        case Defaulted.Provided(value) => Some((Fragment.const0(s""""two""""), fr"${fromWrite(value: Option[String])(Write.fromPutOption(Meta.StringMeta.put))}"))
+        case Defaulted.Provided(value) => Some((Fragment.const0(s""""two""""), fr"${fromWrite(value: Option[String])(new Write.SingleOpt(Meta.StringMeta.put))}"))
       }
     ).flatten
 
@@ -83,24 +83,24 @@ class PersonRepoImpl extends PersonRepo {
   override def selectByFieldValues(fieldValues: List[PersonFieldOrIdValue[?]]): Stream[ConnectionIO, PersonRow] = {
     val where = fragments.whereAndOpt(
       fieldValues.map {
-        case PersonFieldValue.one(value) => fr""""one" = ${fromWrite(value)(Write.fromPut(Meta.LongMeta.put))}"""
-        case PersonFieldValue.two(value) => fr""""two" = ${fromWrite(value)(Write.fromPutOption(Meta.StringMeta.put))}"""
-        case PersonFieldValue.name(value) => fr""""name" = ${fromWrite(value)(Write.fromPutOption(Meta.StringMeta.put))}"""
+        case PersonFieldValue.one(value) => fr""""one" = ${fromWrite(value)(new Write.Single(Meta.LongMeta.put))}"""
+        case PersonFieldValue.two(value) => fr""""two" = ${fromWrite(value)(new Write.SingleOpt(Meta.StringMeta.put))}"""
+        case PersonFieldValue.name(value) => fr""""name" = ${fromWrite(value)(new Write.SingleOpt(Meta.StringMeta.put))}"""
       }
     )
     sql"""select "one", "two", "name" from "compositepk"."person" $where""".query(using PersonRow.read).stream
   }
   override def selectById(compositeId: PersonId): ConnectionIO[Option[PersonRow]] = {
-    sql"""select "one", "two", "name" from "compositepk"."person" where "one" = ${fromWrite(compositeId.one)(Write.fromPut(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(Write.fromPutOption(Meta.StringMeta.put))}""".query(using PersonRow.read).option
+    sql"""select "one", "two", "name" from "compositepk"."person" where "one" = ${fromWrite(compositeId.one)(new Write.Single(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(new Write.SingleOpt(Meta.StringMeta.put))}""".query(using PersonRow.read).option
   }
   override def update: UpdateBuilder[PersonFields, PersonRow] = {
     UpdateBuilder(""""compositepk"."person"""", PersonFields.structure, PersonRow.read)
   }
   override def update(row: PersonRow): ConnectionIO[Boolean] = {
     val compositeId = row.compositeId
     sql"""update "compositepk"."person"
-          set "name" = ${fromWrite(row.name)(Write.fromPutOption(Meta.StringMeta.put))}
-          where "one" = ${fromWrite(compositeId.one)(Write.fromPut(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(Write.fromPutOption(Meta.StringMeta.put))}"""
+          set "name" = ${fromWrite(row.name)(new Write.SingleOpt(Meta.StringMeta.put))}
+          where "one" = ${fromWrite(compositeId.one)(new Write.Single(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(new Write.SingleOpt(Meta.StringMeta.put))}"""
       .update
       .run
       .map(_ > 0)
@@ -111,20 +111,20 @@ class PersonRepoImpl extends PersonRepo {
       case Some(nonEmpty) =>
         val updates = fragments.set(
           nonEmpty.map {
-            case PersonFieldValue.name(value) => fr""""name" = ${fromWrite(value)(Write.fromPutOption(Meta.StringMeta.put))}"""
+            case PersonFieldValue.name(value) => fr""""name" = ${fromWrite(value)(new Write.SingleOpt(Meta.StringMeta.put))}"""
           }
         )
         sql"""update "compositepk"."person"
               $updates
-              where "one" = ${fromWrite(compositeId.one)(Write.fromPut(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(Write.fromPutOption(Meta.StringMeta.put))}""".update.run.map(_ > 0)
+              where "one" = ${fromWrite(compositeId.one)(new Write.Single(Meta.LongMeta.put))} AND "two" = ${fromWrite(compositeId.two)(new Write.SingleOpt(Meta.StringMeta.put))}""".update.run.map(_ > 0)
     }
   }
   override def upsert(unsaved: PersonRow): ConnectionIO[PersonRow] = {
     sql"""insert into "compositepk"."person"("one", "two", "name")
           values (
-            ${fromWrite(unsaved.one)(Write.fromPut(Meta.LongMeta.put))}::int8,
-            ${fromWrite(unsaved.two)(Write.fromPutOption(Meta.StringMeta.put))},
-            ${fromWrite(unsaved.name)(Write.fromPutOption(Meta.StringMeta.put))}
+            ${fromWrite(unsaved.one)(new Write.Single(Meta.LongMeta.put))}::int8,
+            ${fromWrite(unsaved.two)(new Write.SingleOpt(Meta.StringMeta.put))},
+            ${fromWrite(unsaved.name)(new Write.SingleOpt(Meta.StringMeta.put))}
           )
           on conflict ("one", "two")
           do update set

.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/compositepk/person/PersonRow.scala

@@ -8,14 +8,12 @@ package hardcoded
 package compositepk
 package person
 
-import doobie.enumerated.Nullability
 import doobie.postgres.Text
 import doobie.util.Read
 import doobie.util.Write
 import doobie.util.meta.Meta
 import io.circe.Decoder
 import io.circe.Encoder
-import java.sql.ResultSet
 import testdb.hardcoded.customtypes.Defaulted
 
 /** Table: compositepk.person
@@ -38,39 +36,28 @@ object PersonRow {
     new PersonRow(compositeId.one, compositeId.two, name)
   implicit lazy val decoder: Decoder[PersonRow] = Decoder.forProduct3[PersonRow, Long, Option[String], Option[String]]("one", "two", "name")(PersonRow.apply)(Decoder.decodeLong, Decoder.decodeOption(Decoder.decodeString), Decoder.decodeOption(Decoder.decodeString))
   implicit lazy val encoder: Encoder[PersonRow] = Encoder.forProduct3[PersonRow, Long, Option[String], Option[String]]("one", "two", "name")(x => (x.one, x.two, x.name))(Encoder.encodeLong, Encoder.encodeOption(Encoder.encodeString), Encoder.encodeOption(Encoder.encodeString))
-  implicit lazy val read: Read[PersonRow] = new Read[PersonRow](
-    gets = List(
-      (Meta.LongMeta.get, Nullability.NoNulls),
-      (Meta.StringMeta.get, Nullability.Nullable),
-      (Meta.StringMeta.get, Nullability.Nullable)
-    ),
-    unsafeGet = (rs: ResultSet, i: Int) => PersonRow(
-      one = Meta.LongMeta.get.unsafeGetNonNullable(rs, i + 0),
-      two = Meta.StringMeta.get.unsafeGetNullable(rs, i + 1),
-      name = Meta.StringMeta.get.unsafeGetNullable(rs, i + 2)
+  implicit lazy val read: Read[PersonRow] = new Read.CompositeOfInstances(Array(
+    new Read.Single(Meta.LongMeta.get).asInstanceOf[Read[Any]],
+      new Read.SingleOpt(Meta.StringMeta.get).asInstanceOf[Read[Any]],
+      new Read.SingleOpt(Meta.StringMeta.get).asInstanceOf[Read[Any]]
+  ))(using scala.reflect.ClassTag.Any).map { arr =>
+    PersonRow(
+      one = arr(0).asInstanceOf[Long],
+          two = arr(1).asInstanceOf[Option[String]],
+          name = arr(2).asInstanceOf[Option[String]]
     )
-  )
+  }
   implicit lazy val text: Text[PersonRow] = Text.instance[PersonRow]{ (row, sb) =>
     Text.longInstance.unsafeEncode(row.one, sb)
     sb.append(Text.DELIMETER)
     Text.option(Text.stringInstance).unsafeEncode(row.two, sb)
     sb.append(Text.DELIMETER)
     Text.option(Text.stringInstance).unsafeEncode(row.name, sb)
   }
-  implicit lazy val write: Write[PersonRow] = new Write[PersonRow](
-    puts = List((Meta.LongMeta.put, Nullability.NoNulls),
-                (Meta.StringMeta.put, Nullability.Nullable),
-                (Meta.StringMeta.put, Nullability.Nullable)),
-    toList = x => List(x.one, x.two, x.name),
-    unsafeSet = (rs, i, a) => {
-                  Meta.LongMeta.put.unsafeSetNonNullable(rs, i + 0, a.one)
-                  Meta.StringMeta.put.unsafeSetNullable(rs, i + 1, a.two)
-                  Meta.StringMeta.put.unsafeSetNullable(rs, i + 2, a.name)
-                },
-    unsafeUpdate = (ps, i, a) => {
-                     Meta.LongMeta.put.unsafeUpdateNonNullable(ps, i + 0, a.one)
-                     Meta.StringMeta.put.unsafeUpdateNullable(ps, i + 1, a.two)
-                     Meta.StringMeta.put.unsafeUpdateNullable(ps, i + 2, a.name)
-                   }
+  implicit lazy val write: Write[PersonRow] = new Write.Composite[PersonRow](
+    List(new Write.Single(Meta.LongMeta.put),
+         new Write.Single(Meta.StringMeta.put).toOpt,
+         new Write.Single(Meta.StringMeta.put).toOpt),
+    a => List(a.one, a.two, a.name)
   )
 }

.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/myschema/Number.scala

@@ -47,10 +47,10 @@ object Number {
   implicit lazy val get: Get[Number] = Meta.StringMeta.get.temap(Number.apply)
   implicit lazy val ordering: Ordering[Number] = Ordering.by(_.value)
   implicit lazy val put: Put[Number] = Put.Advanced.one[Number](JdbcType.Other, NonEmptyList.one("myschema.number"), (ps, i, a) => ps.setString(i, a.value), (rs, i, a) => rs.updateString(i, a.value))
-  implicit lazy val read: Read[Number] = Read.fromGet(get)
+  implicit lazy val read: Read[Number] = new Read.Single(get)
   implicit lazy val text: Text[Number] = new Text[Number] {
     override def unsafeEncode(v: Number, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb)
     override def unsafeArrayEncode(v: Number, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb)
   }
-  implicit lazy val write: Write[Number] = Write.fromPut(put)
+  implicit lazy val write: Write[Number] = new Write.Single(put)
 }

.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/myschema/Sector.scala

@@ -47,10 +47,10 @@ object Sector {
   implicit lazy val get: Get[Sector] = Meta.StringMeta.get.temap(Sector.apply)
   implicit lazy val ordering: Ordering[Sector] = Ordering.by(_.value)
   implicit lazy val put: Put[Sector] = Put.Advanced.one[Sector](JdbcType.Other, NonEmptyList.one("myschema.sector"), (ps, i, a) => ps.setString(i, a.value), (rs, i, a) => rs.updateString(i, a.value))
-  implicit lazy val read: Read[Sector] = Read.fromGet(get)
+  implicit lazy val read: Read[Sector] = new Read.Single(get)
   implicit lazy val text: Text[Sector] = new Text[Sector] {
     override def unsafeEncode(v: Sector, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb)
     override def unsafeArrayEncode(v: Sector, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb)
   }
-  implicit lazy val write: Write[Sector] = Write.fromPut(put)
+  implicit lazy val write: Write[Sector] = new Write.Single(put)
 }

.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/myschema/football_club/FootballClubRepoImpl.scala

@@ -30,14 +30,14 @@ class FootballClubRepoImpl extends FootballClubRepo {
     DeleteBuilder(""""myschema"."football_club"""", FootballClubFields.structure)
   }
   override def deleteById(id: FootballClubId): ConnectionIO[Boolean] = {
-    sql"""delete from "myschema"."football_club" where "id" = ${fromWrite(id)(Write.fromPut(FootballClubId.put))}""".update.run.map(_ > 0)
+    sql"""delete from "myschema"."football_club" where "id" = ${fromWrite(id)(new Write.Single(FootballClubId.put))}""".update.run.map(_ > 0)
   }
   override def deleteByIds(ids: Array[FootballClubId]): ConnectionIO[Int] = {
     sql"""delete from "myschema"."football_club" where "id" = ANY(${ids})""".update.run
   }
   override def insert(unsaved: FootballClubRow): ConnectionIO[FootballClubRow] = {
     sql"""insert into "myschema"."football_club"("id", "name")
-          values (${fromWrite(unsaved.id)(Write.fromPut(FootballClubId.put))}::int8, ${fromWrite(unsaved.name)(Write.fromPut(Meta.StringMeta.put))})
+          values (${fromWrite(unsaved.id)(new Write.Single(FootballClubId.put))}::int8, ${fromWrite(unsaved.name)(new Write.Single(Meta.StringMeta.put))})
           returning "id", "name"
        """.query(using FootballClubRow.read).unique
   }
@@ -53,14 +53,14 @@ class FootballClubRepoImpl extends FootballClubRepo {
   override def selectByFieldValues(fieldValues: List[FootballClubFieldOrIdValue[?]]): Stream[ConnectionIO, FootballClubRow] = {
     val where = fragments.whereAndOpt(
       fieldValues.map {
-        case FootballClubFieldValue.id(value) => fr""""id" = ${fromWrite(value)(Write.fromPut(FootballClubId.put))}"""
-        case FootballClubFieldValue.name(value) => fr""""name" = ${fromWrite(value)(Write.fromPut(Meta.StringMeta.put))}"""
+        case FootballClubFieldValue.id(value) => fr""""id" = ${fromWrite(value)(new Write.Single(FootballClubId.put))}"""
+        case FootballClubFieldValue.name(value) => fr""""name" = ${fromWrite(value)(new Write.Single(Meta.StringMeta.put))}"""
       }
     )
     sql"""select "id", "name" from "myschema"."football_club" $where""".query(using FootballClubRow.read).stream
   }
   override def selectById(id: FootballClubId): ConnectionIO[Option[FootballClubRow]] = {
-    sql"""select "id", "name" from "myschema"."football_club" where "id" = ${fromWrite(id)(Write.fromPut(FootballClubId.put))}""".query(using FootballClubRow.read).option
+    sql"""select "id", "name" from "myschema"."football_club" where "id" = ${fromWrite(id)(new Write.Single(FootballClubId.put))}""".query(using FootballClubRow.read).option
   }
   override def selectByIds(ids: Array[FootballClubId]): Stream[ConnectionIO, FootballClubRow] = {
     sql"""select "id", "name" from "myschema"."football_club" where "id" = ANY(${ids})""".query(using FootballClubRow.read).stream
@@ -77,8 +77,8 @@ class FootballClubRepoImpl extends FootballClubRepo {
   override def update(row: FootballClubRow): ConnectionIO[Boolean] = {
     val id = row.id
     sql"""update "myschema"."football_club"
-          set "name" = ${fromWrite(row.name)(Write.fromPut(Meta.StringMeta.put))}
-          where "id" = ${fromWrite(id)(Write.fromPut(FootballClubId.put))}"""
+          set "name" = ${fromWrite(row.name)(new Write.Single(Meta.StringMeta.put))}
+          where "id" = ${fromWrite(id)(new Write.Single(FootballClubId.put))}"""
       .update
       .run
       .map(_ > 0)
@@ -89,19 +89,19 @@ class FootballClubRepoImpl extends FootballClubRepo {
       case Some(nonEmpty) =>
         val updates = fragments.set(
           nonEmpty.map {
-            case FootballClubFieldValue.name(value) => fr""""name" = ${fromWrite(value)(Write.fromPut(Meta.StringMeta.put))}"""
+            case FootballClubFieldValue.name(value) => fr""""name" = ${fromWrite(value)(new Write.Single(Meta.StringMeta.put))}"""
           }
         )
         sql"""update "myschema"."football_club"
               $updates
-              where "id" = ${fromWrite(id)(Write.fromPut(FootballClubId.put))}""".update.run.map(_ > 0)
+              where "id" = ${fromWrite(id)(new Write.Single(FootballClubId.put))}""".update.run.map(_ > 0)
     }
   }
   override def upsert(unsaved: FootballClubRow): ConnectionIO[FootballClubRow] = {
     sql"""insert into "myschema"."football_club"("id", "name")
           values (
-            ${fromWrite(unsaved.id)(Write.fromPut(FootballClubId.put))}::int8,
-            ${fromWrite(unsaved.name)(Write.fromPut(Meta.StringMeta.put))}
+            ${fromWrite(unsaved.id)(new Write.Single(FootballClubId.put))}::int8,
+            ${fromWrite(unsaved.name)(new Write.Single(Meta.StringMeta.put))}
           )
           on conflict ("id")
           do update set

.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/myschema/football_club/FootballClubRow.scala

@@ -8,14 +8,12 @@ package hardcoded
 package myschema
 package football_club
 
-import doobie.enumerated.Nullability
 import doobie.postgres.Text
 import doobie.util.Read
 import doobie.util.Write
 import doobie.util.meta.Meta
 import io.circe.Decoder
 import io.circe.Encoder
-import java.sql.ResultSet
 
 /** Table: myschema.football_club
     football club
@@ -28,32 +26,23 @@ case class FootballClubRow(
 object FootballClubRow {
   implicit lazy val decoder: Decoder[FootballClubRow] = Decoder.forProduct2[FootballClubRow, FootballClubId, /* max 100 chars */ String]("id", "name")(FootballClubRow.apply)(FootballClubId.decoder, Decoder.decodeString)
   implicit lazy val encoder: Encoder[FootballClubRow] = Encoder.forProduct2[FootballClubRow, FootballClubId, /* max 100 chars */ String]("id", "name")(x => (x.id, x.name))(FootballClubId.encoder, Encoder.encodeString)
-  implicit lazy val read: Read[FootballClubRow] = new Read[FootballClubRow](
-    gets = List(
-      (FootballClubId.get, Nullability.NoNulls),
-      (Meta.StringMeta.get, Nullability.NoNulls)
-    ),
-    unsafeGet = (rs: ResultSet, i: Int) => FootballClubRow(
-      id = FootballClubId.get.unsafeGetNonNullable(rs, i + 0),
-      name = Meta.StringMeta.get.unsafeGetNonNullable(rs, i + 1)
+  implicit lazy val read: Read[FootballClubRow] = new Read.CompositeOfInstances(Array(
+    new Read.Single(FootballClubId.get).asInstanceOf[Read[Any]],
+      new Read.Single(Meta.StringMeta.get).asInstanceOf[Read[Any]]
+  ))(using scala.reflect.ClassTag.Any).map { arr =>
+    FootballClubRow(
+      id = arr(0).asInstanceOf[FootballClubId],
+          name = arr(1).asInstanceOf[/* max 100 chars */ String]
     )
-  )
+  }
   implicit lazy val text: Text[FootballClubRow] = Text.instance[FootballClubRow]{ (row, sb) =>
     FootballClubId.text.unsafeEncode(row.id, sb)
     sb.append(Text.DELIMETER)
     Text.stringInstance.unsafeEncode(row.name, sb)
   }
-  implicit lazy val write: Write[FootballClubRow] = new Write[FootballClubRow](
-    puts = List((FootballClubId.put, Nullability.NoNulls),
-                (Meta.StringMeta.put, Nullability.NoNulls)),
-    toList = x => List(x.id, x.name),
-    unsafeSet = (rs, i, a) => {
-                  FootballClubId.put.unsafeSetNonNullable(rs, i + 0, a.id)
-                  Meta.StringMeta.put.unsafeSetNonNullable(rs, i + 1, a.name)
-                },
-    unsafeUpdate = (ps, i, a) => {
-                     FootballClubId.put.unsafeUpdateNonNullable(ps, i + 0, a.id)
-                     Meta.StringMeta.put.unsafeUpdateNonNullable(ps, i + 1, a.name)
-                   }
+  implicit lazy val write: Write[FootballClubRow] = new Write.Composite[FootballClubRow](
+    List(new Write.Single(FootballClubId.put),
+         new Write.Single(Meta.StringMeta.put)),
+    a => List(a.id, a.name)
   )
 }