diff --git a/.bleep/generated-sources/typo-tester-anorm@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-anorm@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index 07bc46b83f..0f9803aaa5 100644 --- a/.bleep/generated-sources/typo-tester-anorm@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-anorm@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,20 +6,20 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[scala.Array[scala.math.BigDecimal]] = anorm.ToStatement[scala.Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) - implicit lazy val BooleanArrayToStatement: anorm.ToStatement[scala.Array[scala.Boolean]] = anorm.ToStatement[scala.Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) - implicit lazy val DoubleArrayToStatement: anorm.ToStatement[scala.Array[scala.Double]] = anorm.ToStatement[scala.Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) - implicit lazy val FloatArrayToStatement: anorm.ToStatement[scala.Array[scala.Float]] = anorm.ToStatement[scala.Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) - implicit lazy val IntArrayToStatement: anorm.ToStatement[scala.Array[scala.Int]] = anorm.ToStatement[scala.Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) - implicit lazy val LongArrayToStatement: anorm.ToStatement[scala.Array[scala.Long]] = anorm.ToStatement[scala.Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) + implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[Array[scala.math.BigDecimal]] = anorm.ToStatement[Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) + implicit lazy val BooleanArrayToStatement: anorm.ToStatement[Array[scala.Boolean]] = anorm.ToStatement[Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) + implicit lazy val DoubleArrayToStatement: anorm.ToStatement[Array[scala.Double]] = anorm.ToStatement[Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) + implicit lazy val FloatArrayToStatement: anorm.ToStatement[Array[scala.Float]] = anorm.ToStatement[Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) + implicit lazy val IntArrayToStatement: anorm.ToStatement[Array[scala.Int]] = anorm.ToStatement[Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) + implicit lazy val LongArrayToStatement: anorm.ToStatement[Array[scala.Long]] = anorm.ToStatement[Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) implicit lazy val OffsetTimeReads: play.api.libs.json.Reads[java.time.OffsetTime] = play.api.libs.json.Reads.StringReads.flatMapResult { str => try play.api.libs.json.JsSuccess(java.time.OffsetTime.parse(str)) catch { case x: java.time.format.DateTimeParseException => play.api.libs.json.JsError(s"must follow ${java.time.format.DateTimeFormatter.ISO_OFFSET_TIME}: ${x.getMessage}") } } implicit lazy val OffsetTimeWrites: play.api.libs.json.Writes[java.time.OffsetTime] = play.api.libs.json.Writes.StringWrites.contramap(_.toString) - implicit lazy val ShortArrayToStatement: anorm.ToStatement[scala.Array[scala.Short]] = anorm.ToStatement[scala.Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) - implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[scala.Array[T]] = new anorm.ParameterMetaData[scala.Array[T]] { + implicit lazy val ShortArrayToStatement: anorm.ToStatement[Array[scala.Short]] = anorm.ToStatement[Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) + implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[Array[T]] = new anorm.ParameterMetaData[Array[T]] { override def sqlType: java.lang.String = "_" + T.sqlType override def jdbcType: scala.Int = java.sql.Types.ARRAY } diff --git a/.bleep/generated-sources/typo-tester-anorm@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-anorm@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index 07bc46b83f..0f9803aaa5 100644 --- a/.bleep/generated-sources/typo-tester-anorm@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-anorm@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,20 +6,20 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[scala.Array[scala.math.BigDecimal]] = anorm.ToStatement[scala.Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) - implicit lazy val BooleanArrayToStatement: anorm.ToStatement[scala.Array[scala.Boolean]] = anorm.ToStatement[scala.Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) - implicit lazy val DoubleArrayToStatement: anorm.ToStatement[scala.Array[scala.Double]] = anorm.ToStatement[scala.Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) - implicit lazy val FloatArrayToStatement: anorm.ToStatement[scala.Array[scala.Float]] = anorm.ToStatement[scala.Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) - implicit lazy val IntArrayToStatement: anorm.ToStatement[scala.Array[scala.Int]] = anorm.ToStatement[scala.Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) - implicit lazy val LongArrayToStatement: anorm.ToStatement[scala.Array[scala.Long]] = anorm.ToStatement[scala.Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) + implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[Array[scala.math.BigDecimal]] = anorm.ToStatement[Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) + implicit lazy val BooleanArrayToStatement: anorm.ToStatement[Array[scala.Boolean]] = anorm.ToStatement[Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) + implicit lazy val DoubleArrayToStatement: anorm.ToStatement[Array[scala.Double]] = anorm.ToStatement[Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) + implicit lazy val FloatArrayToStatement: anorm.ToStatement[Array[scala.Float]] = anorm.ToStatement[Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) + implicit lazy val IntArrayToStatement: anorm.ToStatement[Array[scala.Int]] = anorm.ToStatement[Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) + implicit lazy val LongArrayToStatement: anorm.ToStatement[Array[scala.Long]] = anorm.ToStatement[Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) implicit lazy val OffsetTimeReads: play.api.libs.json.Reads[java.time.OffsetTime] = play.api.libs.json.Reads.StringReads.flatMapResult { str => try play.api.libs.json.JsSuccess(java.time.OffsetTime.parse(str)) catch { case x: java.time.format.DateTimeParseException => play.api.libs.json.JsError(s"must follow ${java.time.format.DateTimeFormatter.ISO_OFFSET_TIME}: ${x.getMessage}") } } implicit lazy val OffsetTimeWrites: play.api.libs.json.Writes[java.time.OffsetTime] = play.api.libs.json.Writes.StringWrites.contramap(_.toString) - implicit lazy val ShortArrayToStatement: anorm.ToStatement[scala.Array[scala.Short]] = anorm.ToStatement[scala.Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) - implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[scala.Array[T]] = new anorm.ParameterMetaData[scala.Array[T]] { + implicit lazy val ShortArrayToStatement: anorm.ToStatement[Array[scala.Short]] = anorm.ToStatement[Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) + implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[Array[T]] = new anorm.ParameterMetaData[Array[T]] { override def sqlType: java.lang.String = "_" + T.sqlType override def jdbcType: scala.Int = java.sql.Types.ARRAY } diff --git a/.bleep/generated-sources/typo-tester-anorm@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-anorm@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index 07bc46b83f..0f9803aaa5 100644 --- a/.bleep/generated-sources/typo-tester-anorm@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-anorm@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,20 +6,20 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[scala.Array[scala.math.BigDecimal]] = anorm.ToStatement[scala.Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) - implicit lazy val BooleanArrayToStatement: anorm.ToStatement[scala.Array[scala.Boolean]] = anorm.ToStatement[scala.Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) - implicit lazy val DoubleArrayToStatement: anorm.ToStatement[scala.Array[scala.Double]] = anorm.ToStatement[scala.Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) - implicit lazy val FloatArrayToStatement: anorm.ToStatement[scala.Array[scala.Float]] = anorm.ToStatement[scala.Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) - implicit lazy val IntArrayToStatement: anorm.ToStatement[scala.Array[scala.Int]] = anorm.ToStatement[scala.Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) - implicit lazy val LongArrayToStatement: anorm.ToStatement[scala.Array[scala.Long]] = anorm.ToStatement[scala.Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) + implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[Array[scala.math.BigDecimal]] = anorm.ToStatement[Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) + implicit lazy val BooleanArrayToStatement: anorm.ToStatement[Array[scala.Boolean]] = anorm.ToStatement[Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) + implicit lazy val DoubleArrayToStatement: anorm.ToStatement[Array[scala.Double]] = anorm.ToStatement[Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) + implicit lazy val FloatArrayToStatement: anorm.ToStatement[Array[scala.Float]] = anorm.ToStatement[Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) + implicit lazy val IntArrayToStatement: anorm.ToStatement[Array[scala.Int]] = anorm.ToStatement[Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) + implicit lazy val LongArrayToStatement: anorm.ToStatement[Array[scala.Long]] = anorm.ToStatement[Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) implicit lazy val OffsetTimeReads: play.api.libs.json.Reads[java.time.OffsetTime] = play.api.libs.json.Reads.StringReads.flatMapResult { str => try play.api.libs.json.JsSuccess(java.time.OffsetTime.parse(str)) catch { case x: java.time.format.DateTimeParseException => play.api.libs.json.JsError(s"must follow ${java.time.format.DateTimeFormatter.ISO_OFFSET_TIME}: ${x.getMessage}") } } implicit lazy val OffsetTimeWrites: play.api.libs.json.Writes[java.time.OffsetTime] = play.api.libs.json.Writes.StringWrites.contramap(_.toString) - implicit lazy val ShortArrayToStatement: anorm.ToStatement[scala.Array[scala.Short]] = anorm.ToStatement[scala.Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) - implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[scala.Array[T]] = new anorm.ParameterMetaData[scala.Array[T]] { + implicit lazy val ShortArrayToStatement: anorm.ToStatement[Array[scala.Short]] = anorm.ToStatement[Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) + implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[Array[T]] = new anorm.ParameterMetaData[Array[T]] { override def sqlType: java.lang.String = "_" + T.sqlType override def jdbcType: scala.Int = java.sql.Types.ARRAY } diff --git a/.bleep/generated-sources/typo-tester-doobie@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-doobie@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index ad6d3a66a0..bcc4ce5900 100644 --- a/.bleep/generated-sources/typo-tester-doobie@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-doobie@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,13 +6,13 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[scala.Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta - implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType - implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType - implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType - implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType - implicit lazy val LongArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType - implicit lazy val StringArrayMeta: doobie.util.meta.Meta[scala.Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType - implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[scala.Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType + implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta + implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType + implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType + implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType + implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType + implicit lazy val LongArrayMeta: doobie.util.meta.Meta[Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType + implicit lazy val StringArrayMeta: doobie.util.meta.Meta[Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType + implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType implicit lazy val UUIDMeta: doobie.util.meta.Meta[java.util.UUID] = doobie.postgres.implicits.UuidType } diff --git a/.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index ad6d3a66a0..bcc4ce5900 100644 --- a/.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-doobie@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,13 +6,13 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[scala.Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta - implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType - implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType - implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType - implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType - implicit lazy val LongArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType - implicit lazy val StringArrayMeta: doobie.util.meta.Meta[scala.Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType - implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[scala.Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType + implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta + implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType + implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType + implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType + implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType + implicit lazy val LongArrayMeta: doobie.util.meta.Meta[Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType + implicit lazy val StringArrayMeta: doobie.util.meta.Meta[Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType + implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType implicit lazy val UUIDMeta: doobie.util.meta.Meta[java.util.UUID] = doobie.postgres.implicits.UuidType } diff --git a/.bleep/generated-sources/typo-tester-doobie@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-doobie@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index ad6d3a66a0..bcc4ce5900 100644 --- a/.bleep/generated-sources/typo-tester-doobie@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-doobie@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,13 +6,13 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[scala.Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta - implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType - implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType - implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType - implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType - implicit lazy val LongArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType - implicit lazy val StringArrayMeta: doobie.util.meta.Meta[scala.Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType - implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[scala.Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType + implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta + implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType + implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType + implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType + implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType + implicit lazy val LongArrayMeta: doobie.util.meta.Meta[Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType + implicit lazy val StringArrayMeta: doobie.util.meta.Meta[Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType + implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType implicit lazy val UUIDMeta: doobie.util.meta.Meta[java.util.UUID] = doobie.postgres.implicits.UuidType } diff --git a/.bleep/generated-sources/typo-tester-zio-jdbc@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-zio-jdbc@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index c8ffbefab4..0615f3c1c7 100644 --- a/.bleep/generated-sources/typo-tester-zio-jdbc@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-zio-jdbc@jvm212/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,8 +6,8 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.math.BigDecimal]) = { + implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.math.BigDecimal]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -32,15 +32,15 @@ package object hardcoded { } } } - implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) - implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.math.BigDecimal]]( + implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) + implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.math.BigDecimal]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("numeric", v.map(x => x: scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Boolean]) = { + implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[Array[scala.Boolean]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Boolean]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -65,15 +65,15 @@ package object hardcoded { } } } - implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) - implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Boolean]]( + implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) + implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Boolean]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("bool", v.map(x => boolean2Boolean(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Double]) = { + implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Double]] = new zio.jdbc.JdbcDecoder[Array[scala.Double]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Double]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -98,15 +98,15 @@ package object hardcoded { } } } - implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) - implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Double]]( + implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) + implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Double]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float8", v.map(x => double2Double(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Float]) = { + implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Float]] = new zio.jdbc.JdbcDecoder[Array[scala.Float]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Float]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -131,15 +131,15 @@ package object hardcoded { } } } - implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) - implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Float]]( + implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) + implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Float]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float4", v.map(x => float2Float(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Int]) = { + implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Int]] = new zio.jdbc.JdbcDecoder[Array[scala.Int]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Int]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -164,15 +164,15 @@ package object hardcoded { } } } - implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) - implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Int]]( + implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) + implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Int]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int4", v.map(x => int2Integer(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Long]) = { + implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Long]] = new zio.jdbc.JdbcDecoder[Array[scala.Long]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Long]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -197,18 +197,18 @@ package object hardcoded { } } } - implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) - implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Long]]( + implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) + implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Long]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int8", v.map(x => long2Long(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) - implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) - implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) - implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.lang.String]) = { + implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) + implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) + implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) + implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[Array[java.lang.String]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.lang.String]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -233,8 +233,8 @@ package object hardcoded { } } } - implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) - implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.lang.String]]( + implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) + implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.lang.String]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("varchar", v.map(x => x: scala.AnyRef))) }, diff --git a/.bleep/generated-sources/typo-tester-zio-jdbc@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-zio-jdbc@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index c8ffbefab4..0615f3c1c7 100644 --- a/.bleep/generated-sources/typo-tester-zio-jdbc@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-zio-jdbc@jvm213/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,8 +6,8 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.math.BigDecimal]) = { + implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.math.BigDecimal]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -32,15 +32,15 @@ package object hardcoded { } } } - implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) - implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.math.BigDecimal]]( + implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) + implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.math.BigDecimal]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("numeric", v.map(x => x: scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Boolean]) = { + implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[Array[scala.Boolean]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Boolean]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -65,15 +65,15 @@ package object hardcoded { } } } - implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) - implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Boolean]]( + implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) + implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Boolean]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("bool", v.map(x => boolean2Boolean(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Double]) = { + implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Double]] = new zio.jdbc.JdbcDecoder[Array[scala.Double]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Double]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -98,15 +98,15 @@ package object hardcoded { } } } - implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) - implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Double]]( + implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) + implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Double]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float8", v.map(x => double2Double(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Float]) = { + implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Float]] = new zio.jdbc.JdbcDecoder[Array[scala.Float]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Float]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -131,15 +131,15 @@ package object hardcoded { } } } - implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) - implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Float]]( + implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) + implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Float]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float4", v.map(x => float2Float(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Int]) = { + implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Int]] = new zio.jdbc.JdbcDecoder[Array[scala.Int]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Int]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -164,15 +164,15 @@ package object hardcoded { } } } - implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) - implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Int]]( + implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) + implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Int]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int4", v.map(x => int2Integer(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Long]) = { + implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Long]] = new zio.jdbc.JdbcDecoder[Array[scala.Long]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Long]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -197,18 +197,18 @@ package object hardcoded { } } } - implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) - implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Long]]( + implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) + implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Long]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int8", v.map(x => long2Long(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) - implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) - implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) - implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.lang.String]) = { + implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) + implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) + implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) + implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[Array[java.lang.String]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.lang.String]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -233,8 +233,8 @@ package object hardcoded { } } } - implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) - implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.lang.String]]( + implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) + implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.lang.String]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("varchar", v.map(x => x: scala.AnyRef))) }, diff --git a/.bleep/generated-sources/typo-tester-zio-jdbc@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala b/.bleep/generated-sources/typo-tester-zio-jdbc@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala index c8ffbefab4..0615f3c1c7 100644 --- a/.bleep/generated-sources/typo-tester-zio-jdbc@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala +++ b/.bleep/generated-sources/typo-tester-zio-jdbc@jvm3/scripts.GenHardcodedFiles/testdb/hardcoded/package.scala @@ -6,8 +6,8 @@ package testdb package object hardcoded { - implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.math.BigDecimal]) = { + implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.math.BigDecimal]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -32,15 +32,15 @@ package object hardcoded { } } } - implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) - implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.math.BigDecimal]]( + implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) + implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.math.BigDecimal]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("numeric", v.map(x => x: scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Boolean]) = { + implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[Array[scala.Boolean]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Boolean]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -65,15 +65,15 @@ package object hardcoded { } } } - implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) - implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Boolean]]( + implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) + implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Boolean]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("bool", v.map(x => boolean2Boolean(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Double]) = { + implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Double]] = new zio.jdbc.JdbcDecoder[Array[scala.Double]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Double]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -98,15 +98,15 @@ package object hardcoded { } } } - implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) - implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Double]]( + implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) + implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Double]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float8", v.map(x => double2Double(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Float]) = { + implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Float]] = new zio.jdbc.JdbcDecoder[Array[scala.Float]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Float]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -131,15 +131,15 @@ package object hardcoded { } } } - implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) - implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Float]]( + implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) + implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Float]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float4", v.map(x => float2Float(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Int]) = { + implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Int]] = new zio.jdbc.JdbcDecoder[Array[scala.Int]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Int]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -164,15 +164,15 @@ package object hardcoded { } } } - implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) - implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Int]]( + implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) + implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Int]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int4", v.map(x => int2Integer(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Long]) = { + implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Long]] = new zio.jdbc.JdbcDecoder[Array[scala.Long]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Long]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -197,18 +197,18 @@ package object hardcoded { } } } - implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) - implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Long]]( + implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) + implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Long]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int8", v.map(x => long2Long(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) - implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) - implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) - implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.lang.String]) = { + implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) + implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) + implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) + implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[Array[java.lang.String]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.lang.String]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -233,8 +233,8 @@ package object hardcoded { } } } - implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) - implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.lang.String]]( + implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) + implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.lang.String]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("varchar", v.map(x => x: scala.AnyRef))) }, diff --git a/typo-tester-anorm/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala b/typo-tester-anorm/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala index 394b104b3f..77e429114a 100644 --- a/typo-tester-anorm/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala +++ b/typo-tester-anorm/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala @@ -24,7 +24,7 @@ object TypoBytea { implicit lazy val column: Column[TypoBytea] = Column.nonNull[TypoBytea]((v1: Any, _) => v1 match { case v: Array[Byte] => Right(TypoBytea(v)) - case other => Left(TypeDoesNotMatch(s"Expected instance of scala.Array[scala.Byte], got ${other.getClass.getName}")) + case other => Left(TypeDoesNotMatch(s"Expected instance of Array[scala.Byte], got ${other.getClass.getName}")) } ) implicit def ordering(implicit O0: Ordering[Array[Byte]]): Ordering[TypoBytea] = Ordering.by(_.value) diff --git a/typo-tester-anorm/generated-and-checked-in/adventureworks/package.scala b/typo-tester-anorm/generated-and-checked-in/adventureworks/package.scala index da5dbc2fec..b68f555ebf 100644 --- a/typo-tester-anorm/generated-and-checked-in/adventureworks/package.scala +++ b/typo-tester-anorm/generated-and-checked-in/adventureworks/package.scala @@ -6,20 +6,20 @@ package object adventureworks { - implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[scala.Array[scala.math.BigDecimal]] = anorm.ToStatement[scala.Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) - implicit lazy val BooleanArrayToStatement: anorm.ToStatement[scala.Array[scala.Boolean]] = anorm.ToStatement[scala.Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) - implicit lazy val DoubleArrayToStatement: anorm.ToStatement[scala.Array[scala.Double]] = anorm.ToStatement[scala.Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) - implicit lazy val FloatArrayToStatement: anorm.ToStatement[scala.Array[scala.Float]] = anorm.ToStatement[scala.Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) - implicit lazy val IntArrayToStatement: anorm.ToStatement[scala.Array[scala.Int]] = anorm.ToStatement[scala.Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) - implicit lazy val LongArrayToStatement: anorm.ToStatement[scala.Array[scala.Long]] = anorm.ToStatement[scala.Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) + implicit lazy val BigDecimalArrayToStatement: anorm.ToStatement[Array[scala.math.BigDecimal]] = anorm.ToStatement[Array[scala.math.BigDecimal]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("numeric", v.map(v => v.bigDecimal)))) + implicit lazy val BooleanArrayToStatement: anorm.ToStatement[Array[scala.Boolean]] = anorm.ToStatement[Array[scala.Boolean]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("bool", v.map(v => v: java.lang.Boolean)))) + implicit lazy val DoubleArrayToStatement: anorm.ToStatement[Array[scala.Double]] = anorm.ToStatement[Array[scala.Double]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float8", v.map(v => v: java.lang.Double)))) + implicit lazy val FloatArrayToStatement: anorm.ToStatement[Array[scala.Float]] = anorm.ToStatement[Array[scala.Float]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("float4", v.map(v => v: java.lang.Float)))) + implicit lazy val IntArrayToStatement: anorm.ToStatement[Array[scala.Int]] = anorm.ToStatement[Array[scala.Int]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int4", v.map(v => v: java.lang.Integer)))) + implicit lazy val LongArrayToStatement: anorm.ToStatement[Array[scala.Long]] = anorm.ToStatement[Array[scala.Long]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int8", v.map(v => v: java.lang.Long)))) implicit lazy val OffsetTimeReads: play.api.libs.json.Reads[java.time.OffsetTime] = play.api.libs.json.Reads.StringReads.flatMapResult { str => try play.api.libs.json.JsSuccess(java.time.OffsetTime.parse(str)) catch { case x: java.time.format.DateTimeParseException => play.api.libs.json.JsError(s"must follow ${java.time.format.DateTimeFormatter.ISO_OFFSET_TIME}: ${x.getMessage}") } } implicit lazy val OffsetTimeWrites: play.api.libs.json.Writes[java.time.OffsetTime] = play.api.libs.json.Writes.StringWrites.contramap(_.toString) - implicit lazy val ShortArrayToStatement: anorm.ToStatement[scala.Array[scala.Short]] = anorm.ToStatement[scala.Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) - implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[scala.Array[T]] = new anorm.ParameterMetaData[scala.Array[T]] { + implicit lazy val ShortArrayToStatement: anorm.ToStatement[Array[scala.Short]] = anorm.ToStatement[Array[scala.Short]]((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf("int2", v.map(v => v: java.lang.Short)))) + implicit def arrayParameterMetaData[T](implicit T: anorm.ParameterMetaData[T]): anorm.ParameterMetaData[Array[T]] = new anorm.ParameterMetaData[Array[T]] { override def sqlType: java.lang.String = "_" + T.sqlType override def jdbcType: scala.Int = java.sql.Types.ARRAY } diff --git a/typo-tester-doobie/generated-and-checked-in/adventureworks/package.scala b/typo-tester-doobie/generated-and-checked-in/adventureworks/package.scala index ae9d32ffd3..66d710056d 100644 --- a/typo-tester-doobie/generated-and-checked-in/adventureworks/package.scala +++ b/typo-tester-doobie/generated-and-checked-in/adventureworks/package.scala @@ -6,13 +6,13 @@ package object adventureworks { - implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[scala.Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta - implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType - implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType - implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType - implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType - implicit lazy val LongArrayMeta: doobie.util.meta.Meta[scala.Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType - implicit lazy val StringArrayMeta: doobie.util.meta.Meta[scala.Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType - implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[scala.Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType + implicit lazy val BigDecimalMeta: doobie.util.meta.Meta[Array[scala.math.BigDecimal]] = doobie.postgres.implicits.bigDecimalMeta + implicit lazy val BooleanArrayMeta: doobie.util.meta.Meta[Array[scala.Boolean]] = doobie.postgres.implicits.unliftedUnboxedBooleanArrayType + implicit lazy val DoubleArrayMeta: doobie.util.meta.Meta[Array[scala.Double]] = doobie.postgres.implicits.unliftedUnboxedDoubleArrayType + implicit lazy val FloatArrayMeta: doobie.util.meta.Meta[Array[scala.Float]] = doobie.postgres.implicits.unliftedUnboxedFloatArrayType + implicit lazy val IntegerArrayMeta: doobie.util.meta.Meta[Array[scala.Int]] = doobie.postgres.implicits.unliftedUnboxedIntegerArrayType + implicit lazy val LongArrayMeta: doobie.util.meta.Meta[Array[scala.Long]] = doobie.postgres.implicits.unliftedUnboxedLongArrayType + implicit lazy val StringArrayMeta: doobie.util.meta.Meta[Array[java.lang.String]] = doobie.postgres.implicits.unliftedStringArrayType + implicit lazy val UUIDArrayMeta: doobie.util.meta.Meta[Array[java.util.UUID]] = doobie.postgres.implicits.unliftedUUIDArrayType implicit lazy val UUIDMeta: doobie.util.meta.Meta[java.util.UUID] = doobie.postgres.implicits.UuidType } diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBox.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBox.scala index 16ef4f58f1..1960cec792 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBox.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBox.scala @@ -28,7 +28,7 @@ object TypoBox { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoBox(x.asInstanceOf[PGbox].point(0).x, x.asInstanceOf[PGbox].point(0).y, x.asInstanceOf[PGbox].point(1).x, x.asInstanceOf[PGbox].point(1).y)) }, - "scala.Array[org.postgresql.geometric.PGbox]" + "Array[org.postgresql.geometric.PGbox]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoBox]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoBox]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala index 0860f31768..9fa5721f9b 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoBytea.scala @@ -27,7 +27,7 @@ object TypoBytea { val v = rs.getObject(i) if (v eq null) null else TypoBytea(v.asInstanceOf[Array[Byte]]) }, - "scala.Array[scala.Byte]" + "Array[scala.Byte]" ) implicit lazy val jdbcEncoder: JdbcEncoder[TypoBytea] = JdbcEncoder.singleParamEncoder(setter) implicit lazy val jsonDecoder: JsonDecoder[TypoBytea] = JsonDecoder.array[Byte](JsonDecoder.byte, implicitly).map(TypoBytea.apply) diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoCircle.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoCircle.scala index 2ef01d05ae..27dd15d32e 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoCircle.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoCircle.scala @@ -28,7 +28,7 @@ object TypoCircle { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoCircle(TypoPoint(x.asInstanceOf[PGcircle].center.x, x.asInstanceOf[PGcircle].center.y), x.asInstanceOf[PGcircle].radius)) }, - "scala.Array[org.postgresql.geometric.PGcircle]" + "Array[org.postgresql.geometric.PGcircle]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoCircle]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoCircle]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInet.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInet.scala index 4636220648..c1bd30cacf 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInet.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInet.scala @@ -27,7 +27,7 @@ object TypoInet { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoInet(x.asInstanceOf[PGobject].getValue)) }, - "scala.Array[org.postgresql.util.PGobject]" + "Array[org.postgresql.util.PGobject]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoInet]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoInet]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInstant.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInstant.scala index 3dd2a95581..abd2e9d278 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInstant.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInstant.scala @@ -36,7 +36,7 @@ object TypoInstant { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoInstant(x.asInstanceOf[String])) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoInstant]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoInstant]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInt2Vector.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInt2Vector.scala index ad7aa433f8..d6fe26b308 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInt2Vector.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInt2Vector.scala @@ -27,7 +27,7 @@ object TypoInt2Vector { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoInt2Vector(x.asInstanceOf[PGobject].getValue)) }, - "scala.Array[org.postgresql.util.PGobject]" + "Array[org.postgresql.util.PGobject]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoInt2Vector]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoInt2Vector]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInterval.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInterval.scala index 0b962e519b..5db15f08f2 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInterval.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoInterval.scala @@ -28,7 +28,7 @@ object TypoInterval { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoInterval(x.asInstanceOf[PGInterval].getYears, x.asInstanceOf[PGInterval].getMonths, x.asInstanceOf[PGInterval].getDays, x.asInstanceOf[PGInterval].getHours, x.asInstanceOf[PGInterval].getMinutes, x.asInstanceOf[PGInterval].getSeconds)) }, - "scala.Array[org.postgresql.util.PGInterval]" + "Array[org.postgresql.util.PGInterval]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoInterval]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoInterval]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJson.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJson.scala index e611122acf..c6b252f59a 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJson.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJson.scala @@ -27,7 +27,7 @@ object TypoJson { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoJson(x.asInstanceOf[String])) }, - "scala.Array[org.postgresql.util.PGobject]" + "Array[org.postgresql.util.PGobject]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoJson]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoJson]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJsonb.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJsonb.scala index 0831427a45..7b59c85975 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJsonb.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoJsonb.scala @@ -27,7 +27,7 @@ object TypoJsonb { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoJsonb(x.asInstanceOf[String])) }, - "scala.Array[org.postgresql.util.PGobject]" + "Array[org.postgresql.util.PGobject]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoJsonb]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoJsonb]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLine.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLine.scala index 5141c28b2f..9ff9da3eca 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLine.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLine.scala @@ -28,7 +28,7 @@ object TypoLine { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoLine(x.asInstanceOf[PGline].a, x.asInstanceOf[PGline].b, x.asInstanceOf[PGline].c)) }, - "scala.Array[org.postgresql.geometric.PGline]" + "Array[org.postgresql.geometric.PGline]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoLine]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoLine]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLineSegment.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLineSegment.scala index 97f4a615dd..7d83e99e72 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLineSegment.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLineSegment.scala @@ -29,7 +29,7 @@ object TypoLineSegment { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoLineSegment(TypoPoint(x.asInstanceOf[PGlseg].point(0).x, x.asInstanceOf[PGlseg].point(0).y), TypoPoint(x.asInstanceOf[PGlseg].point(1).x, x.asInstanceOf[PGlseg].point(1).y))) }, - "scala.Array[org.postgresql.geometric.PGlseg]" + "Array[org.postgresql.geometric.PGlseg]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoLineSegment]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoLineSegment]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDate.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDate.scala index 1cb00e49b9..960dad4634 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDate.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDate.scala @@ -29,7 +29,7 @@ object TypoLocalDate { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoLocalDate(LocalDate.parse(x.asInstanceOf[String]))) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoLocalDate]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoLocalDate]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDateTime.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDateTime.scala index bd4371a5aa..899279909c 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDateTime.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalDateTime.scala @@ -35,7 +35,7 @@ object TypoLocalDateTime { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoLocalDateTime(LocalDateTime.parse(x.asInstanceOf[String], parser))) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoLocalDateTime]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoLocalDateTime]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalTime.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalTime.scala index aa6072987c..bf1462f480 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalTime.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoLocalTime.scala @@ -31,7 +31,7 @@ object TypoLocalTime { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoLocalTime(LocalTime.parse(x.asInstanceOf[String]))) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoLocalTime]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoLocalTime]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoMoney.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoMoney.scala index e029ed0c21..965009935c 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoMoney.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoMoney.scala @@ -26,7 +26,7 @@ object TypoMoney { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoMoney(BigDecimal(x.asInstanceOf[java.math.BigDecimal]))) }, - "scala.Array[java.math.BigDecimal]" + "Array[java.math.BigDecimal]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoMoney]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoMoney]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoOffsetTime.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoOffsetTime.scala index bb768f6a15..8dc0257604 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoOffsetTime.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoOffsetTime.scala @@ -35,7 +35,7 @@ object TypoOffsetTime { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoOffsetTime(OffsetTime.parse(x.asInstanceOf[String], parser))) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoOffsetTime]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoOffsetTime]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPath.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPath.scala index 8ead180d12..0cea483600 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPath.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPath.scala @@ -29,7 +29,7 @@ object TypoPath { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoPath(x.asInstanceOf[PGpath].isOpen, x.asInstanceOf[PGpath].points.map(p => TypoPoint(p.x, p.y)).toList)) }, - "scala.Array[org.postgresql.geometric.PGpath]" + "Array[org.postgresql.geometric.PGpath]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoPath]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoPath]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPoint.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPoint.scala index 7e28e8b6bd..e0c20d2c99 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPoint.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPoint.scala @@ -28,7 +28,7 @@ object TypoPoint { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoPoint(x.asInstanceOf[PGpoint].x, x.asInstanceOf[PGpoint].y)) }, - "scala.Array[org.postgresql.geometric.PGpoint]" + "Array[org.postgresql.geometric.PGpoint]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoPoint]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoPoint]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPolygon.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPolygon.scala index 0285d4b2f3..75aa6f74d8 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPolygon.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoPolygon.scala @@ -28,7 +28,7 @@ object TypoPolygon { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoPolygon(x.asInstanceOf[PGpolygon].points.map(p => TypoPoint(p.x, p.y)).toList)) }, - "scala.Array[org.postgresql.geometric.PGpolygon]" + "Array[org.postgresql.geometric.PGpolygon]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoPolygon]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoPolygon]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoRecord.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoRecord.scala index d2ad93d282..d63d88c287 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoRecord.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoRecord.scala @@ -27,7 +27,7 @@ object TypoRecord { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoRecord(x.asInstanceOf[PGobject].getValue)) }, - "scala.Array[org.postgresql.util.PGobject]" + "Array[org.postgresql.util.PGobject]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoRecord]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoRecord]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoShort.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoShort.scala index 1ca0d2e4b8..cc683f9c96 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoShort.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoShort.scala @@ -40,7 +40,7 @@ object TypoShort { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoShort(x.asInstanceOf[java.lang.Short])) }, - "scala.Array[java.lang.Integer]" + "Array[java.lang.Integer]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoShort]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoShort]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUUID.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUUID.scala index f272715c97..5e5dff4994 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUUID.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUUID.scala @@ -29,7 +29,7 @@ object TypoUUID { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoUUID(x.asInstanceOf[UUID])) }, - "scala.Array[java.util.UUID]" + "Array[java.util.UUID]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoUUID]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoUUID]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUnknownCitext.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUnknownCitext.scala index 97d533340d..2ad729c1fb 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUnknownCitext.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoUnknownCitext.scala @@ -26,7 +26,7 @@ object TypoUnknownCitext { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoUnknownCitext(x.asInstanceOf[String])) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoUnknownCitext]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoUnknownCitext]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoVector.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoVector.scala index d70dd1655b..683aca7ea0 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoVector.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoVector.scala @@ -28,7 +28,7 @@ object TypoVector { val v = rs.getObject(i) if (v eq null) null else TypoVector(v.asInstanceOf[PgArray].getArray.asInstanceOf[Array[java.lang.Float]].map(Float2float)) }, - "scala.Array[java.lang.Float]" + "Array[java.lang.Float]" ) implicit lazy val jdbcEncoder: JdbcEncoder[TypoVector] = JdbcEncoder.singleParamEncoder(setter) implicit lazy val jsonDecoder: JsonDecoder[TypoVector] = JsonDecoder.array[Float](JsonDecoder.float, implicitly).map(TypoVector.apply) diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoXml.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoXml.scala index 788b845624..8e736dfe79 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoXml.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/customtypes/TypoXml.scala @@ -28,7 +28,7 @@ object TypoXml { case null => null case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => TypoXml(x.asInstanceOf[PGobject].getValue)) }, - "scala.Array[java.lang.String]" + "Array[java.lang.String]" ) implicit lazy val arrayJdbcEncoder: JdbcEncoder[Array[TypoXml]] = JdbcEncoder.singleParamEncoder(arraySetter) implicit lazy val arraySetter: Setter[Array[TypoXml]] = Setter.forSqlType((ps, i, v) => diff --git a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/package.scala b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/package.scala index 0803ca4ec6..6f3ad5574d 100644 --- a/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/package.scala +++ b/typo-tester-zio-jdbc/generated-and-checked-in/adventureworks/package.scala @@ -6,8 +6,8 @@ package object adventureworks { - implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[scala.Array[java.math.BigDecimal]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.math.BigDecimal]) = { + implicit lazy val BigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] = new zio.jdbc.JdbcDecoder[Array[java.math.BigDecimal]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.math.BigDecimal]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -32,15 +32,15 @@ package object adventureworks { } } } - implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) - implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.math.BigDecimal]]( + implicit lazy val BigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.math.BigDecimal]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BigDecimalArraySetter) + implicit lazy val BigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.math.BigDecimal]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.math.BigDecimal]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("numeric", v.map(x => x: scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Boolean]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Boolean]) = { + implicit lazy val BooleanArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Boolean]] = new zio.jdbc.JdbcDecoder[Array[scala.Boolean]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Boolean]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -65,15 +65,15 @@ package object adventureworks { } } } - implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) - implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Boolean]]( + implicit lazy val BooleanArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Boolean]] = zio.jdbc.JdbcEncoder.singleParamEncoder(BooleanArraySetter) + implicit lazy val BooleanArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Boolean]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Boolean]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("bool", v.map(x => boolean2Boolean(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Double]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Double]) = { + implicit lazy val DoubleArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Double]] = new zio.jdbc.JdbcDecoder[Array[scala.Double]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Double]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -98,15 +98,15 @@ package object adventureworks { } } } - implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) - implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Double]]( + implicit lazy val DoubleArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Double]] = zio.jdbc.JdbcEncoder.singleParamEncoder(DoubleArraySetter) + implicit lazy val DoubleArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Double]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Double]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float8", v.map(x => double2Double(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Float]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Float]) = { + implicit lazy val FloatArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Float]] = new zio.jdbc.JdbcDecoder[Array[scala.Float]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Float]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -131,15 +131,15 @@ package object adventureworks { } } } - implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) - implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Float]]( + implicit lazy val FloatArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Float]] = zio.jdbc.JdbcEncoder.singleParamEncoder(FloatArraySetter) + implicit lazy val FloatArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Float]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Float]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("float4", v.map(x => float2Float(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Int]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Int]) = { + implicit lazy val IntArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Int]] = new zio.jdbc.JdbcDecoder[Array[scala.Int]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Int]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -164,15 +164,15 @@ package object adventureworks { } } } - implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) - implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Int]]( + implicit lazy val IntArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Int]] = zio.jdbc.JdbcEncoder.singleParamEncoder(IntArraySetter) + implicit lazy val IntArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Int]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Int]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int4", v.map(x => int2Integer(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] = new zio.jdbc.JdbcDecoder[scala.Array[scala.Long]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[scala.Long]) = { + implicit lazy val LongArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.Long]] = new zio.jdbc.JdbcDecoder[Array[scala.Long]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[scala.Long]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -197,18 +197,18 @@ package object adventureworks { } } } - implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) - implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[scala.Long]]( + implicit lazy val LongArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.Long]] = zio.jdbc.JdbcEncoder.singleParamEncoder(LongArraySetter) + implicit lazy val LongArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.Long]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[scala.Long]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("int8", v.map(x => long2Long(x): scala.AnyRef))) }, java.sql.Types.ARRAY ) - implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) - implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) - implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) - implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[scala.Array[java.lang.String]] { - override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, scala.Array[java.lang.String]) = { + implicit lazy val ScalaBigDecimalArrayDecoder: zio.jdbc.JdbcDecoder[Array[scala.math.BigDecimal]] = BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(scala.math.BigDecimal.apply)) + implicit lazy val ScalaBigDecimalArrayEncoder: zio.jdbc.JdbcEncoder[Array[scala.math.BigDecimal]] = BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal)) + implicit lazy val ScalaBigDecimalArraySetter: zio.jdbc.SqlFragment.Setter[Array[scala.math.BigDecimal]] = BigDecimalArraySetter.contramap(_.map(_.bigDecimal)) + implicit lazy val StringArrayDecoder: zio.jdbc.JdbcDecoder[Array[java.lang.String]] = new zio.jdbc.JdbcDecoder[Array[java.lang.String]] { + override def unsafeDecode(columIndex: scala.Int, rs: java.sql.ResultSet): (scala.Int, Array[java.lang.String]) = { val arr = rs.getArray(columIndex) if (arr eq null) columIndex -> null else { @@ -233,8 +233,8 @@ package object adventureworks { } } } - implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[scala.Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) - implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[scala.Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[scala.Array[java.lang.String]]( + implicit lazy val StringArrayEncoder: zio.jdbc.JdbcEncoder[Array[java.lang.String]] = zio.jdbc.JdbcEncoder.singleParamEncoder(StringArraySetter) + implicit lazy val StringArraySetter: zio.jdbc.SqlFragment.Setter[Array[java.lang.String]] = zio.jdbc.SqlFragment.Setter.forSqlType[Array[java.lang.String]]( (ps, i, v) => { ps.setArray(i, ps.getConnection.createArrayOf("varchar", v.map(x => x: scala.AnyRef))) }, diff --git a/typo/src/scala/typo/TypesScala.scala b/typo/src/scala/typo/TypesScala.scala index fc299bc177..f0fe3d7749 100644 --- a/typo/src/scala/typo/TypesScala.scala +++ b/typo/src/scala/typo/TypesScala.scala @@ -36,6 +36,7 @@ object TypesScala { object Optional { def unapply(tpe: sc.Type): Option[sc.Type] = tpe match { + case sc.Type.ArrayOf(_) => scala.None case sc.Type.Wildcard => scala.None case sc.Type.TApply(Option, scala.List(one)) => scala.Some(one) case sc.Type.TApply(underlying, _) => unapply(underlying) diff --git a/typo/src/scala/typo/internal/ComputedTable.scala b/typo/src/scala/typo/internal/ComputedTable.scala index d448b7468b..b64277147f 100644 --- a/typo/src/scala/typo/internal/ComputedTable.scala +++ b/typo/src/scala/typo/internal/ComputedTable.scala @@ -148,7 +148,7 @@ case class ComputedTable( maybeId.collect { // todo: support composite ids case unary: IdComputed.Unary => - RepoMethod.SelectAllByIds(dbTable.name, cols, unary, sc.Param(unary.paramName.appended("s"), TypesScala.Array.of(unary.tpe), None), names.RowName) + RepoMethod.SelectAllByIds(dbTable.name, cols, unary, sc.Param(unary.paramName.appended("s"), sc.Type.ArrayOf(unary.tpe), None), names.RowName) }, for { name <- names.FieldOrIdValueName diff --git a/typo/src/scala/typo/internal/ComputedTestInserts.scala b/typo/src/scala/typo/internal/ComputedTestInserts.scala index 7dfa603942..b21ca35ab2 100644 --- a/typo/src/scala/typo/internal/ComputedTestInserts.scala +++ b/typo/src/scala/typo/internal/ComputedTestInserts.scala @@ -49,7 +49,7 @@ object ComputedTestInserts { case None => Some(TypesScala.None.code) case Some(default) => Some(code"if ($random.nextBoolean()) ${TypesScala.None} else ${TypesScala.Some}($default)") } - case sc.Type.TApply(TypesScala.Array, List(underlying)) => + case sc.Type.ArrayOf(underlying) => dbType match { case db.Type.Array(underlyingDb) => go(underlying, underlyingDb).map { default => diff --git a/typo/src/scala/typo/internal/CustomTypes.scala b/typo/src/scala/typo/internal/CustomTypes.scala index 841bfcedde..1bf0f3190a 100644 --- a/typo/src/scala/typo/internal/CustomTypes.scala +++ b/typo/src/scala/typo/internal/CustomTypes.scala @@ -33,18 +33,18 @@ class CustomTypes(pkg: sc.QIdent) { sqlType = "bytea", typoType = sc.Type.Qualified(pkg / sc.Ident("TypoBytea")), params = NonEmptyList( - sc.Param(sc.Ident("value"), TypesScala.Array.of(TypesScala.Byte), None) + sc.Param(sc.Ident("value"), sc.Type.ArrayOf(TypesScala.Byte), None) ), toTypo = CustomType.ToTypo( - jdbcType = TypesScala.Array.of(TypesScala.Byte), + jdbcType = sc.Type.ArrayOf(TypesScala.Byte), toTypo = (expr, target) => code"$target($expr)" ), fromTypo = CustomType.FromTypo( - jdbcType = TypesScala.Array.of(TypesScala.Byte), + jdbcType = sc.Type.ArrayOf(TypesScala.Byte), fromTypo = (expr, _) => code"$expr.value" ), forbidArray = true, - toText = CustomType.Text(TypesScala.Array.of(TypesScala.Byte), expr => code"$expr.value") + toText = CustomType.Text(sc.Type.ArrayOf(TypesScala.Byte), expr => code"$expr.value") ) lazy val TypoLocalDate = CustomType( @@ -436,14 +436,14 @@ class CustomTypes(pkg: sc.QIdent) { sqlType = "vector", typoType = sc.Type.Qualified(pkg / sc.Ident("TypoVector")), params = NonEmptyList( - sc.Param(sc.Ident("value"), TypesScala.Array.of(TypesScala.Float), None) + sc.Param(sc.Ident("value"), sc.Type.ArrayOf(TypesScala.Float), None) ), toTypo = CustomType.ToTypo( jdbcType = TypesJava.PgArray, - toTypo = (expr, target) => code"$target($expr.getArray.asInstanceOf[${TypesScala.Array.of(TypesJava.Float)}].map(Float2float))" + toTypo = (expr, target) => code"$target($expr.getArray.asInstanceOf[${sc.Type.ArrayOf(TypesJava.Float)}].map(Float2float))" ), fromTypo = CustomType.FromTypo( - jdbcType = TypesScala.Array.of(TypesJava.Float), + jdbcType = sc.Type.ArrayOf(TypesJava.Float), fromTypo = (expr, _) => code"$expr.value.map(x => x: ${TypesJava.Float})" ), forbidArray = true, diff --git a/typo/src/scala/typo/internal/TypeMapperScala.scala b/typo/src/scala/typo/internal/TypeMapperScala.scala index e3c1d276f3..a6b3208463 100644 --- a/typo/src/scala/typo/internal/TypeMapperScala.scala +++ b/typo/src/scala/typo/internal/TypeMapperScala.scala @@ -17,7 +17,7 @@ case class TypeMapperScala( val baseTpe = col.tpe match { case db.Type.Array(tpe) => - TypesScala.Array.of(go(tpe)) + sc.Type.ArrayOf(go(tpe)) case other => go(other) } @@ -31,7 +31,7 @@ case class TypeMapperScala( val base = dbType match { case db.Type.Array(tpe) => - TypesScala.Array.of(go(tpe)) + sc.Type.ArrayOf(go(tpe)) case other => go(other) } @@ -44,7 +44,7 @@ case class TypeMapperScala( def domain(dbType: db.Type): sc.Type = dbType match { case db.Type.Array(tpe) => - TypesScala.Array.of(baseType(tpe)) + sc.Type.ArrayOf(baseType(tpe)) case other => baseType(other) } @@ -128,7 +128,9 @@ case class TypeMapperScala( def stripOptionAndArray(tpe: sc.Type): sc.Type = tpe match { - case sc.Type.TApply(TypesScala.Option | TypesScala.Array, List(tpe)) => + case sc.Type.ArrayOf(tpe) => + stripOptionAndArray(tpe) + case sc.Type.TApply(TypesScala.Option, List(tpe)) => stripOptionAndArray(tpe) case sc.Type.TApply(other, targs) => sc.Type.TApply(stripOptionAndArray(other), targs.map(stripOptionAndArray)) diff --git a/typo/src/scala/typo/internal/codegen/DbLibAnorm.scala b/typo/src/scala/typo/internal/codegen/DbLibAnorm.scala index 87fe9dba31..75ea48e35c 100644 --- a/typo/src/scala/typo/internal/codegen/DbLibAnorm.scala +++ b/typo/src/scala/typo/internal/codegen/DbLibAnorm.scala @@ -86,12 +86,12 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa case x if missingInstancesByType.contains(Column.of(x)) => code"${missingInstancesByType(Column.of(x))}" // generated array type - case sc.Type.TApply(TypesScala.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => + case sc.Type.ArrayOf(targ: sc.Type.Qualified) if targ.value.idents.startsWith(pkg.idents) => code"$targ.$arrayColumnName" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$Column.columnToByteArray" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$Column.columnToByteArray" // fallback array case. implementation looks loco, but I guess it works - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$Column.columnToArray[$targ](${lookupColumnFor(targ)}, implicitly)" - case other => sc.Summon(Column.of(other)).code + case sc.Type.ArrayOf(targ) => code"$Column.columnToArray[$targ](${lookupColumnFor(targ)}, implicitly)" + case other => sc.Summon(Column.of(other)).code } /** Resolve known implicits at generation-time instead of at compile-time */ @@ -118,10 +118,10 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa // generated array type // case sc.Type.TApply(ScalaTypes.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => // code"$targ.$arrayColumnName" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$ParameterMetaData.ByteArrayParameterMetaData" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$ParameterMetaData.ByteArrayParameterMetaData" // fallback array case. - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"${pkg / arrayParameterMetaDataName}(${lookupParameterMetaDataFor(targ)})" - case other => sc.Summon(ParameterMetaData.of(other)).code + case sc.Type.ArrayOf(targ) => code"${pkg / arrayParameterMetaDataName}(${lookupParameterMetaDataFor(targ)})" + case other => sc.Summon(ParameterMetaData.of(other)).code } /** Resolve known implicits at generation-time instead of at compile-time */ @@ -145,12 +145,12 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa // customized type mapping case x if missingInstancesByType.contains(ToStatement.of(x)) => code"${missingInstancesByType(ToStatement.of(x))}" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$ToStatement.byteArrayToStatement" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$ToStatement.byteArrayToStatement" // generated array type - case sc.Type.TApply(TypesScala.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => + case sc.Type.ArrayOf(targ: sc.Type.Qualified) if targ.value.idents.startsWith(pkg.idents) => code"$targ.$arrayToStatementName" // fallback array case. - case sc.Type.TApply(TypesScala.Array, List(targ)) => + case sc.Type.ArrayOf(targ) => // `ToStatement.arrayToParameter` does not work for arbitrary types. if it's a user-defined type, user needs to provide this too if (sc.Type.containsUserDefined(tpe)) // should be `targ`, but this information is stripped in `sc.Type.base` above code"$targ.arrayToStatement" @@ -168,7 +168,7 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa case RepoMethod.SelectAllByIds(_, _, unaryId, idsParam, rowType) => unaryId match { case IdComputed.UnaryUserSpecified(_, tpe) => - code"def selectByIds($idsParam)(implicit c: ${TypesJava.Connection}, toStatement: ${ToStatement.of(TypesScala.Array.of(tpe))}): ${TypesScala.List.of(rowType)}" + code"def selectByIds($idsParam)(implicit c: ${TypesJava.Connection}, toStatement: ${ToStatement.of(sc.Type.ArrayOf(tpe))}): ${TypesScala.List.of(rowType)}" case _ => code"def selectByIds($idsParam)(implicit c: ${TypesJava.Connection}): ${TypesScala.List.of(rowType)}" } @@ -556,7 +556,7 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa tparams = Nil, name = arrayColumnName, implicitParams = Nil, - tpe = Column.of(TypesScala.Array.of(wrapperType)), + tpe = Column.of(sc.Type.ArrayOf(wrapperType)), body = code"""$Column.columnToArray($columnName, implicitly)""" ) ), @@ -583,8 +583,8 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa tparams = Nil, name = arrayToStatementName, implicitParams = Nil, - tpe = ToStatement.of(TypesScala.Array.of(wrapperType)), - body = code"${lookupToStatementFor(TypesScala.Array.of(underlying))}.contramap(_.map(_.value))" + tpe = ToStatement.of(sc.Type.ArrayOf(wrapperType)), + body = code"${lookupToStatementFor(sc.Type.ArrayOf(underlying))}.contramap(_.map(_.value))" ) ), Some( @@ -618,8 +618,8 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa tparams = Nil, name = arrayToStatementName, implicitParams = Nil, - tpe = ToStatement.of(TypesScala.Array.of(wrapperType)), - body = code"${lookupToStatementFor(TypesScala.Array.of(underlying))}.contramap(_.map(_.value))" + tpe = ToStatement.of(sc.Type.ArrayOf(wrapperType)), + body = code"${lookupToStatementFor(sc.Type.ArrayOf(underlying))}.contramap(_.map(_.value))" ) ), Some( @@ -627,7 +627,7 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa tparams = Nil, name = arrayColumnName, implicitParams = Nil, - tpe = Column.of(TypesScala.Array.of(wrapperType)), + tpe = Column.of(sc.Type.ArrayOf(wrapperType)), body = code"$Column.columnToArray($columnName, implicitly)" ) ), @@ -664,7 +664,7 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa (TypesScala.Boolean, sc.StrLit("bool")), (TypesScala.Double, sc.StrLit("float8")) ).flatMap { case (tpe, elemType) => - val arrayType = TypesScala.Array.of(tpe) + val arrayType = sc.Type.ArrayOf(tpe) val boxedType = TypesScala.boxedType(tpe).getOrElse(TypesScala.AnyRef) List( sc.Given( @@ -681,8 +681,8 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa Nil, sc.Ident("BigDecimalArrayToStatement"), Nil, - ToStatement.of(TypesScala.Array.of(TypesScala.BigDecimal)), - code"${ToStatement.of(TypesScala.Array.of(TypesScala.BigDecimal))}((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf(${sc.StrLit("numeric")}, v.map(v => v.bigDecimal))))" + ToStatement.of(sc.Type.ArrayOf(TypesScala.BigDecimal)), + code"${ToStatement.of(sc.Type.ArrayOf(TypesScala.BigDecimal))}((ps, index, v) => ps.setArray(index, ps.getConnection.createArrayOf(${sc.StrLit("numeric")}, v.map(v => v.bigDecimal))))" ) val arrayParameterMetaData = { @@ -691,8 +691,8 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa List(T), arrayParameterMetaDataName, List(sc.Param(T.value, ParameterMetaData.of(T), None)), - ParameterMetaData.of(TypesScala.Array.of(T)), - code"""|new ${ParameterMetaData.of(TypesScala.Array.of(T))} { + ParameterMetaData.of(sc.Type.ArrayOf(T)), + code"""|new ${ParameterMetaData.of(sc.Type.ArrayOf(T))} { | override def sqlType: ${TypesJava.String} = ${sc.StrLit("_")} + $T.sqlType | override def jdbcType: ${TypesScala.Int} = ${TypesJava.SqlTypes}.ARRAY |}""".stripMargin @@ -784,19 +784,19 @@ class DbLibAnorm(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDefa Nil, arrayToStatementName, Nil, - ToStatement.of(TypesScala.Array.of(tpe)), - code"${ToStatement.of(TypesScala.Array.of(tpe))}((s, index, v) => s.setArray(index, s.getConnection.createArrayOf(${sc.StrLit(ct.sqlType)}, $v.map(v => ${fromTypo.fromTypo0(v)}))))" + ToStatement.of(sc.Type.ArrayOf(tpe)), + code"${ToStatement.of(sc.Type.ArrayOf(tpe))}((s, index, v) => s.setArray(index, s.getConnection.createArrayOf(${sc.StrLit(ct.sqlType)}, $v.map(v => ${fromTypo.fromTypo0(v)}))))" ), sc.Given( Nil, arrayColumnName, Nil, - Column.of(TypesScala.Array.of(tpe)), - code"""|$Column.nonNull[${TypesScala.Array.of(tpe)}]((v1: ${TypesScala.Any}, _) => + Column.of(sc.Type.ArrayOf(tpe)), + code"""|$Column.nonNull[${sc.Type.ArrayOf(tpe)}]((v1: ${TypesScala.Any}, _) => | v1 match { | case $v: ${TypesJava.PgArray} => | $v.getArray match { - | case $v: ${TypesScala.Array.of(sc.Type.Wildcard)} => + | case $v: ${sc.Type.ArrayOf(sc.Type.Wildcard)} => | ${TypesScala.Right}($v.map($v => ${toTypo.toTypo(code"$v.asInstanceOf[${toTypo.jdbcType}]", ct.typoType)})) | case other => ${TypesScala.Left}($TypeDoesNotMatch(s"Expected one-dimensional array from JDBC to produce an array of ${ct.typoType}, got $${other.getClass.getName}")) | } diff --git a/typo/src/scala/typo/internal/codegen/DbLibDoobie.scala b/typo/src/scala/typo/internal/codegen/DbLibDoobie.scala index 634c1115d9..5cae48a727 100644 --- a/typo/src/scala/typo/internal/codegen/DbLibDoobie.scala +++ b/typo/src/scala/typo/internal/codegen/DbLibDoobie.scala @@ -70,7 +70,7 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef case RepoMethod.SelectAllByIds(_, _, unaryId, idsParam, rowType) => unaryId match { case IdComputed.UnaryUserSpecified(_, tpe) => - code"def selectByIds($idsParam)(implicit puts: ${Put.of(TypesScala.Array.of(tpe))}): ${fs2Stream.of(ConnectionIO, rowType)}" + code"def selectByIds($idsParam)(implicit puts: ${Put.of(sc.Type.ArrayOf(tpe))}): ${fs2Stream.of(ConnectionIO, rowType)}" case _ => code"def selectByIds($idsParam): ${fs2Stream.of(ConnectionIO, rowType)}" } @@ -452,8 +452,8 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef tparams = Nil, name = arrayPutName, implicitParams = Nil, - tpe = Put.of(TypesScala.Array.of(wrapperType)), - body = code"""${lookupPutFor(TypesScala.Array.of(underlying))}.contramap(_.map(_.value))""" + tpe = Put.of(sc.Type.ArrayOf(wrapperType)), + body = code"""${lookupPutFor(sc.Type.ArrayOf(underlying))}.contramap(_.map(_.value))""" ) ), Some( @@ -470,8 +470,8 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef tparams = Nil, name = arrayGetName, implicitParams = Nil, - tpe = Get.of(TypesScala.Array.of(wrapperType)), - body = code"""${lookupGetFor(TypesScala.Array.of(underlying))}.map(_.map(force))""" + tpe = Get.of(sc.Type.ArrayOf(wrapperType)), + body = code"""${lookupGetFor(sc.Type.ArrayOf(underlying))}.map(_.map(force))""" ) ), Some( @@ -520,8 +520,8 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef tparams = Nil, name = arrayPutName, implicitParams = Nil, - tpe = Put.of(TypesScala.Array.of(wrapperType)), - body = code"${lookupPutFor(TypesScala.Array.of(underlying))}.contramap(_.map(_.value))" + tpe = Put.of(sc.Type.ArrayOf(wrapperType)), + body = code"${lookupPutFor(sc.Type.ArrayOf(underlying))}.contramap(_.map(_.value))" ) ), Some( @@ -529,8 +529,8 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef tparams = Nil, name = arrayGetName, implicitParams = Nil, - tpe = Get.of(TypesScala.Array.of(wrapperType)), - body = code"${lookupGetFor(TypesScala.Array.of(underlying))}.map(_.map($wrapperType.apply))" + tpe = Get.of(sc.Type.ArrayOf(wrapperType)), + body = code"${lookupGetFor(sc.Type.ArrayOf(underlying))}.map(_.map($wrapperType.apply))" ) ), textSupport.map(_.anyValInstance(wrapperType, underlying)) @@ -542,14 +542,14 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef List( i("UUIDMeta", TypesJava.UUID, "doobie.postgres.implicits.UuidType"), - i("UUIDArrayMeta", TypesScala.Array.of(TypesJava.UUID), "doobie.postgres.implicits.unliftedUUIDArrayType"), - i("StringArrayMeta", TypesScala.Array.of(TypesJava.String), "doobie.postgres.implicits.unliftedStringArrayType"), - i("BooleanArrayMeta", TypesScala.Array.of(TypesScala.Boolean), "doobie.postgres.implicits.unliftedUnboxedBooleanArrayType"), - i("IntegerArrayMeta", TypesScala.Array.of(TypesScala.Int), "doobie.postgres.implicits.unliftedUnboxedIntegerArrayType"), - i("LongArrayMeta", TypesScala.Array.of(TypesScala.Long), "doobie.postgres.implicits.unliftedUnboxedLongArrayType"), - i("FloatArrayMeta", TypesScala.Array.of(TypesScala.Float), "doobie.postgres.implicits.unliftedUnboxedFloatArrayType"), - i("DoubleArrayMeta", TypesScala.Array.of(TypesScala.Double), "doobie.postgres.implicits.unliftedUnboxedDoubleArrayType"), - i("BigDecimalMeta", TypesScala.Array.of(TypesScala.BigDecimal), "doobie.postgres.implicits.bigDecimalMeta") + i("UUIDArrayMeta", sc.Type.ArrayOf(TypesJava.UUID), "doobie.postgres.implicits.unliftedUUIDArrayType"), + i("StringArrayMeta", sc.Type.ArrayOf(TypesJava.String), "doobie.postgres.implicits.unliftedStringArrayType"), + i("BooleanArrayMeta", sc.Type.ArrayOf(TypesScala.Boolean), "doobie.postgres.implicits.unliftedUnboxedBooleanArrayType"), + i("IntegerArrayMeta", sc.Type.ArrayOf(TypesScala.Int), "doobie.postgres.implicits.unliftedUnboxedIntegerArrayType"), + i("LongArrayMeta", sc.Type.ArrayOf(TypesScala.Long), "doobie.postgres.implicits.unliftedUnboxedLongArrayType"), + i("FloatArrayMeta", sc.Type.ArrayOf(TypesScala.Float), "doobie.postgres.implicits.unliftedUnboxedFloatArrayType"), + i("DoubleArrayMeta", sc.Type.ArrayOf(TypesScala.Double), "doobie.postgres.implicits.unliftedUnboxedDoubleArrayType"), + i("BigDecimalMeta", sc.Type.ArrayOf(TypesScala.BigDecimal), "doobie.postgres.implicits.bigDecimalMeta") ) } @@ -569,11 +569,11 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef case TypesScala.Int => code"$Meta.IntMeta.get" case TypesScala.Long => code"$Meta.LongMeta.get" case TypesJava.String => code"$Meta.StringMeta.get" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => + case sc.Type.ArrayOf(TypesScala.Byte) => code"$Meta.ByteArrayMeta.get" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$getName" - case sc.Type.TApply(TypesScala.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => + case sc.Type.ArrayOf(targ: sc.Type.Qualified) if targ.value.idents.startsWith(pkg.idents) => code"$targ.$arrayGetName" case x if missingInstancesByType.contains(Meta.of(x)) => code"${missingInstancesByType(Meta.of(x))}.get" @@ -594,11 +594,11 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef case TypesScala.Int => code"$Meta.IntMeta.put" case TypesScala.Long => code"$Meta.LongMeta.put" case TypesJava.String => code"$Meta.StringMeta.put" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => + case sc.Type.ArrayOf(TypesScala.Byte) => code"$Meta.ByteArrayMeta.put" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$putName" - case sc.Type.TApply(TypesScala.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => + case sc.Type.ArrayOf(targ: sc.Type.Qualified) if targ.value.idents.startsWith(pkg.idents) => code"$targ.$arrayPutName" case x if missingInstancesByType.contains(Meta.of(x)) => code"${missingInstancesByType(Meta.of(x))}.put" @@ -680,7 +680,7 @@ class DbLibDoobie(pkg: sc.QIdent, inlineImplicits: Boolean, default: ComputedDef val fromTypo = ct.fromTypoInArray.getOrElse(ct.fromTypo) val toTypo = ct.toTypoInArray.getOrElse(ct.toTypo) val sqlArrayTypeLit = sc.StrLit("_" + ct.sqlType) - val arrayType = TypesScala.Array.of(ct.typoType) + val arrayType = sc.Type.ArrayOf(ct.typoType) List( sc.Given( tparams = Nil, diff --git a/typo/src/scala/typo/internal/codegen/DbLibTextSupport.scala b/typo/src/scala/typo/internal/codegen/DbLibTextSupport.scala index 5e4e7b3058..05e4ada497 100644 --- a/typo/src/scala/typo/internal/codegen/DbLibTextSupport.scala +++ b/typo/src/scala/typo/internal/codegen/DbLibTextSupport.scala @@ -24,11 +24,11 @@ class DbLibTextSupport(pkg: sc.QIdent, inlineImplicits: Boolean, externalText: O case TypesScala.Int => code"$Text.intInstance" case TypesScala.Long => code"$Text.longInstance" case TypesJava.String => code"$Text.stringInstance" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$Text.byteArrayInstance" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$Text.byteArrayInstance" case TypesScala.Optional(targ) => code"$Text.option(${lookupTextFor(targ)})" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$textName(${lookupTextFor(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$textName" - case sc.Type.TApply(TypesScala.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => + case sc.Type.ArrayOf(targ: sc.Type.Qualified) if targ.value.idents.startsWith(pkg.idents) => code"$Text.iterableInstance[${TypesScala.Array}, $targ](${lookupTextFor(targ)}, implicitly)" case other => code"${Text.of(other)}" } diff --git a/typo/src/scala/typo/internal/codegen/DbLibZioJdbc.scala b/typo/src/scala/typo/internal/codegen/DbLibZioJdbc.scala index f09aefe7bb..dca5a21917 100644 --- a/typo/src/scala/typo/internal/codegen/DbLibZioJdbc.scala +++ b/typo/src/scala/typo/internal/codegen/DbLibZioJdbc.scala @@ -66,17 +66,17 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean if (!inlineImplicits) JdbcDecoder.of(tpe) else sc.Type.base(tpe) match { - case TypesScala.BigDecimal => code"$JdbcDecoder.bigDecimalDecoderScala" - case TypesScala.Boolean => code"$JdbcDecoder.booleanDecoder" - case TypesScala.Byte => code"$JdbcDecoder.byteDecoder" - case TypesScala.Double => code"$JdbcDecoder.doubleDecoder" - case TypesScala.Float => code"$JdbcDecoder.floatDecoder" - case TypesScala.Int => code"$JdbcDecoder.intDecoder" - case TypesScala.Long => code"$JdbcDecoder.longDecoder" - case TypesJava.String => code"$JdbcDecoder.stringDecoder" - case TypesJava.UUID => code"$JdbcDecoder.uuidDecoder" - case TypesScala.Optional(targ) => code"$JdbcDecoder.optionDecoder(${lookupJdbcDecoder(targ)})" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$JdbcDecoder.byteArrayDecoder" + case TypesScala.BigDecimal => code"$JdbcDecoder.bigDecimalDecoderScala" + case TypesScala.Boolean => code"$JdbcDecoder.booleanDecoder" + case TypesScala.Byte => code"$JdbcDecoder.byteDecoder" + case TypesScala.Double => code"$JdbcDecoder.doubleDecoder" + case TypesScala.Float => code"$JdbcDecoder.floatDecoder" + case TypesScala.Int => code"$JdbcDecoder.intDecoder" + case TypesScala.Long => code"$JdbcDecoder.longDecoder" + case TypesJava.String => code"$JdbcDecoder.stringDecoder" + case TypesJava.UUID => code"$JdbcDecoder.uuidDecoder" + case TypesScala.Optional(targ) => code"$JdbcDecoder.optionDecoder(${lookupJdbcDecoder(targ)})" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$JdbcDecoder.byteArrayDecoder" // generated type case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$x.$jdbcDecoderName" @@ -91,17 +91,17 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean if (!inlineImplicits) JdbcEncoder.of(tpe) else sc.Type.base(tpe) match { - case TypesScala.BigDecimal => code"$JdbcEncoder.bigDecimalEncoderScala" - case TypesScala.Boolean => code"$JdbcEncoder.booleanEncoder" - case TypesScala.Byte => code"$JdbcEncoder.byteEncoder" - case TypesScala.Double => code"$JdbcEncoder.doubleEncoder" - case TypesScala.Float => code"$JdbcEncoder.floatEncoder" - case TypesScala.Int => code"$JdbcEncoder.intEncoder" - case TypesScala.Long => code"$JdbcEncoder.longEncoder" - case TypesJava.String => code"$JdbcEncoder.stringEncoder" - case TypesJava.UUID => code"$JdbcEncoder.uuidEncoder" - case TypesScala.Optional(targ) => code"$JdbcEncoder.optionEncoder(${lookupJdbcEncoder(targ)})" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$JdbcEncoder.byteArrayEncoder" + case TypesScala.BigDecimal => code"$JdbcEncoder.bigDecimalEncoderScala" + case TypesScala.Boolean => code"$JdbcEncoder.booleanEncoder" + case TypesScala.Byte => code"$JdbcEncoder.byteEncoder" + case TypesScala.Double => code"$JdbcEncoder.doubleEncoder" + case TypesScala.Float => code"$JdbcEncoder.floatEncoder" + case TypesScala.Int => code"$JdbcEncoder.intEncoder" + case TypesScala.Long => code"$JdbcEncoder.longEncoder" + case TypesJava.String => code"$JdbcEncoder.stringEncoder" + case TypesJava.UUID => code"$JdbcEncoder.uuidEncoder" + case TypesScala.Optional(targ) => code"$JdbcEncoder.optionEncoder(${lookupJdbcEncoder(targ)})" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$JdbcEncoder.byteArrayEncoder" // generated type case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$x.$jdbcEncoderName" @@ -116,21 +116,21 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean if (!inlineImplicits) Setter.of(tpe) else sc.Type.base(tpe) match { - case TypesScala.BigDecimal => code"$Setter.bigDecimalScalaSetter" - case TypesScala.Boolean => code"$Setter.booleanSetter" - case TypesScala.Byte => code"$Setter.byteSetter" - case TypesScala.Double => code"$Setter.doubleSetter" - case TypesScala.Float => code"$Setter.floatSetter" - case TypesScala.Int => code"$Setter.intSetter" - case TypesScala.Long => code"$Setter.longSetter" - case TypesJava.String => code"$Setter.stringSetter" - case TypesJava.UUID => code"$Setter.uuidParamSetter" - case TypesScala.Optional(targ) => code"$Setter.optionParamSetter(${lookupSetter(targ)})" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$Setter.byteArraySetter" + case TypesScala.BigDecimal => code"$Setter.bigDecimalScalaSetter" + case TypesScala.Boolean => code"$Setter.booleanSetter" + case TypesScala.Byte => code"$Setter.byteSetter" + case TypesScala.Double => code"$Setter.doubleSetter" + case TypesScala.Float => code"$Setter.floatSetter" + case TypesScala.Int => code"$Setter.intSetter" + case TypesScala.Long => code"$Setter.longSetter" + case TypesJava.String => code"$Setter.stringSetter" + case TypesJava.UUID => code"$Setter.uuidParamSetter" + case TypesScala.Optional(targ) => code"$Setter.optionParamSetter(${lookupSetter(targ)})" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$Setter.byteArraySetter" // generated type case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$setterName" - case sc.Type.TApply(TypesScala.Array, List(targ: sc.Type.Qualified)) if targ.value.idents.startsWith(pkg.idents) => + case sc.Type.ArrayOf(targ: sc.Type.Qualified) if targ.value.idents.startsWith(pkg.idents) => code"$targ.$arraySetterName" case x if missingInstancesByType.contains(Setter.of(x)) => code"${missingInstancesByType(Setter.of(x))}" @@ -159,10 +159,10 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean // customized type mapping case x if missingInstancesByType.contains(ParameterMetaData.of(x)) => code"${missingInstancesByType(ParameterMetaData.of(x))}" - case sc.Type.TApply(TypesScala.Array, List(TypesScala.Byte)) => code"$ParameterMetaData.ByteArrayParameterMetaData" + case sc.Type.ArrayOf(TypesScala.Byte) => code"$ParameterMetaData.ByteArrayParameterMetaData" // fallback array case. - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$ParameterMetaData.arrayParameterMetaData(${lookupParameterMetaDataFor(targ)})" - case other => sc.Summon(ParameterMetaData.of(other)).code + case sc.Type.ArrayOf(targ) => code"$ParameterMetaData.arrayParameterMetaData(${lookupParameterMetaDataFor(targ)})" + case other => sc.Summon(ParameterMetaData.of(other)).code } private def runtimeInterpolateValue(name: sc.Code, tpe: sc.Type, forbidInline: Boolean = false): sc.Code = { @@ -189,7 +189,7 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean case RepoMethod.SelectAllByIds(_, _, unaryId, idsParam, rowType) => unaryId match { case IdComputed.UnaryUserSpecified(_, tpe) => - code"def selectByIds($idsParam)(implicit encoder: ${JdbcEncoder.of(TypesScala.Array.of(tpe))}): ${ZStream.of(ZConnection, Throwable, rowType)}" + code"def selectByIds($idsParam)(implicit encoder: ${JdbcEncoder.of(sc.Type.ArrayOf(tpe))}): ${ZStream.of(ZConnection, Throwable, rowType)}" case _ => code"def selectByIds($idsParam): ${ZStream.of(ZConnection, Throwable, rowType)}" } @@ -554,21 +554,21 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean tparams = Nil, name = arraySetterName, implicitParams = Nil, - tpe = Setter.of(TypesScala.Array.of(wrapperType)), - body = code"""${lookupSetter(TypesScala.Array.of(underlying))}.contramap(_.map(_.value))""" + tpe = Setter.of(sc.Type.ArrayOf(wrapperType)), + body = code"""${lookupSetter(sc.Type.ArrayOf(underlying))}.contramap(_.map(_.value))""" ) val arrayJdbcDecoder = sc.Given( tparams = Nil, name = arrayJdbcDecoderName, implicitParams = Nil, - tpe = JdbcDecoder.of(TypesScala.Array.of(wrapperType)), - body = code"""${lookupJdbcDecoder(TypesScala.Array.of(underlying))}.map(a => if (a == null) null else a.map(force))""" + tpe = JdbcDecoder.of(sc.Type.ArrayOf(wrapperType)), + body = code"""${lookupJdbcDecoder(sc.Type.ArrayOf(underlying))}.map(a => if (a == null) null else a.map(force))""" ) val arrayJdbcEncoder = sc.Given( tparams = Nil, name = arrayJdbcEncoderName, implicitParams = Nil, - tpe = JdbcEncoder.of(TypesScala.Array.of(wrapperType)), + tpe = JdbcEncoder.of(sc.Type.ArrayOf(wrapperType)), // JdbcEncoder for unary types defined in terms of `Setter` body = code"""$JdbcEncoder.singleParamEncoder(${arraySetterName})""" ) @@ -661,8 +661,8 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean tparams = Nil, name = arraySetterName, implicitParams = Nil, - tpe = Setter.of(TypesScala.Array.of(wrapperType)), - body = code"""${lookupSetter(TypesScala.Array.of(underlying))}.contramap(_.map(_.value))""" + tpe = Setter.of(sc.Type.ArrayOf(wrapperType)), + body = code"""${lookupSetter(sc.Type.ArrayOf(underlying))}.contramap(_.map(_.value))""" ) ), ifDsl( @@ -685,8 +685,8 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean */ def primitiveArrayDecoder(T: sc.Type.Qualified) = { val body = - code"""|new ${JdbcDecoder.of(TypesScala.Array.of(T))} { - | override def unsafeDecode(columIndex: ${TypesScala.Int}, rs: ${TypesJava.ResultSet}): (${TypesScala.Int}, ${TypesScala.Array.of(T)}) = { + code"""|new ${JdbcDecoder.of(sc.Type.ArrayOf(T))} { + | override def unsafeDecode(columIndex: ${TypesScala.Int}, rs: ${TypesJava.ResultSet}): (${TypesScala.Int}, ${sc.Type.ArrayOf(T)}) = { | val arr = rs.getArray(columIndex) | if (arr eq null) columIndex -> null | else { @@ -711,19 +711,19 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean | } | } |}""".stripMargin - sc.Given(tparams = Nil, name = sc.Ident(s"${T.name.value}ArrayDecoder"), implicitParams = Nil, tpe = JdbcDecoder.of(TypesScala.Array.of(T)), body = body) + sc.Given(tparams = Nil, name = sc.Ident(s"${T.name.value}ArrayDecoder"), implicitParams = Nil, tpe = JdbcDecoder.of(sc.Type.ArrayOf(T)), body = body) } def primitiveArraySetter(T: sc.Type.Qualified, sqlType: sc.StrLit, asAnyRef: sc.Code => sc.Code) = { val v = sc.Ident("v") val body = - code"""|$Setter.forSqlType[${TypesScala.Array.of(T)}]( + code"""|$Setter.forSqlType[${sc.Type.ArrayOf(T)}]( | (ps, i, $v) => { | ps.setArray(i, ps.getConnection.createArrayOf($sqlType, ${asAnyRef(v)})) | }, | ${TypesJava.SqlTypes}.ARRAY |)""".stripMargin - sc.Given(tparams = Nil, name = sc.Ident(s"${T.name.value}ArraySetter"), implicitParams = Nil, tpe = Setter.of(TypesScala.Array.of(T)), body = body) + sc.Given(tparams = Nil, name = sc.Ident(s"${T.name.value}ArraySetter"), implicitParams = Nil, tpe = Setter.of(sc.Type.ArrayOf(T)), body = body) } def primitiveArrayEncoder(T: sc.Type.Qualified) = { @@ -731,7 +731,7 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean tparams = Nil, name = sc.Ident(s"${T.name.value}ArrayEncoder"), implicitParams = Nil, - tpe = JdbcEncoder.of(TypesScala.Array.of(T)), + tpe = JdbcEncoder.of(sc.Type.ArrayOf(T)), body = code"""$JdbcEncoder.singleParamEncoder(${T.name.value}ArraySetter)""" ) } @@ -742,21 +742,21 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean tparams = Nil, name = sc.Ident("ScalaBigDecimalArrayEncoder"), implicitParams = Nil, - tpe = JdbcEncoder.of(TypesScala.Array.of(TypesScala.BigDecimal)), + tpe = JdbcEncoder.of(sc.Type.ArrayOf(TypesScala.BigDecimal)), body = code"""BigDecimalArrayEncoder.contramap(_.map(_.bigDecimal))""" ), sc.Given( tparams = Nil, name = sc.Ident("ScalaBigDecimalArrayDecoder"), implicitParams = Nil, - tpe = JdbcDecoder.of(TypesScala.Array.of(TypesScala.BigDecimal)), + tpe = JdbcDecoder.of(sc.Type.ArrayOf(TypesScala.BigDecimal)), body = code"""BigDecimalArrayDecoder.map(v => if (v eq null) null else v.map(${TypesScala.BigDecimal}.apply))""" ), sc.Given( tparams = Nil, name = sc.Ident("ScalaBigDecimalArraySetter"), implicitParams = Nil, - tpe = Setter.of(TypesScala.Array.of(TypesScala.BigDecimal)), + tpe = Setter.of(sc.Type.ArrayOf(TypesScala.BigDecimal)), body = code"""BigDecimalArraySetter.contramap(_.map(_.bigDecimal))""" ) ) @@ -861,22 +861,22 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean tparams = Nil, name = arrayJdbcEncoderName, implicitParams = Nil, - tpe = JdbcEncoder.of(TypesScala.Array.of(ct.typoType)), + tpe = JdbcEncoder.of(sc.Type.ArrayOf(ct.typoType)), // JdbcEncoder for unary types defined in terms of `Setter` body = code"""$JdbcEncoder.singleParamEncoder(${arraySetterName})""" ) val jdbcDecoder = { - val expectedType = sc.StrLit(TypesScala.Array.of(ct.fromTypo.jdbcType).render.asString) + val expectedType = sc.StrLit(sc.Type.ArrayOf(ct.fromTypo.jdbcType).render.asString) val body = - code"""|${JdbcDecoder.of(TypesScala.Array.of(ct.typoType))}((rs: ${TypesJava.ResultSet}) => (i: ${TypesScala.Int}) => + code"""|${JdbcDecoder.of(sc.Type.ArrayOf(ct.typoType))}((rs: ${TypesJava.ResultSet}) => (i: ${TypesScala.Int}) => | rs.getArray(i) match { | case null => null | case arr => arr.getArray.asInstanceOf[Array[AnyRef]].map(x => ${toTypo.toTypo(code"x.asInstanceOf[${toTypo.jdbcType}]", ct.typoType)}) | }, | $expectedType |)""".stripMargin - sc.Given(tparams = Nil, name = arrayJdbcDecoderName, implicitParams = Nil, tpe = JdbcDecoder.of(TypesScala.Array.of(ct.typoType)), body = body) + sc.Given(tparams = Nil, name = arrayJdbcDecoderName, implicitParams = Nil, tpe = JdbcDecoder.of(sc.Type.ArrayOf(ct.typoType)), body = body) } val setter = { @@ -896,7 +896,7 @@ class DbLibZioJdbc(pkg: sc.QIdent, inlineImplicits: Boolean, dslEnabled: Boolean | ${TypesJava.SqlTypes}.ARRAY |)""".stripMargin - sc.Given(tparams = Nil, name = arraySetterName, implicitParams = Nil, tpe = Setter.of(TypesScala.Array.of(ct.typoType)), body = body) + sc.Given(tparams = Nil, name = arraySetterName, implicitParams = Nil, tpe = Setter.of(sc.Type.ArrayOf(ct.typoType)), body = body) } List(jdbcEncoder, jdbcDecoder, setter) diff --git a/typo/src/scala/typo/internal/codegen/JsonLibCirce.scala b/typo/src/scala/typo/internal/codegen/JsonLibCirce.scala index dc9302f931..12af7be1c8 100644 --- a/typo/src/scala/typo/internal/codegen/JsonLibCirce.scala +++ b/typo/src/scala/typo/internal/codegen/JsonLibCirce.scala @@ -31,7 +31,7 @@ case class JsonLibCirce(pkg: sc.QIdent, default: ComputedDefault, inlineImplicit case TypesJava.OffsetTime => code"$Decoder.decodeOffsetTime" case TypesJava.String => code"$Decoder.decodeString" case TypesJava.UUID => code"$Decoder.decodeUUID" - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$Decoder.decodeArray[$targ](${go(targ)}, implicitly)" + case sc.Type.ArrayOf(targ) => code"$Decoder.decodeArray[$targ](${go(targ)}, implicitly)" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$decoderName(${go(targ)})" case TypesScala.Optional(targ) => code"$Decoder.decodeOption(${go(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$decoderName" @@ -60,7 +60,7 @@ case class JsonLibCirce(pkg: sc.QIdent, default: ComputedDefault, inlineImplicit case TypesJava.OffsetTime => code"$Encoder.encodeOffsetTime" case TypesJava.String => code"$Encoder.encodeString" case TypesJava.UUID => code"$Encoder.encodeUUID" - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$Encoder.encodeIterable[$targ, ${TypesScala.Array}](${go(targ)}, implicitly)" + case sc.Type.ArrayOf(targ) => code"$Encoder.encodeIterable[$targ, ${TypesScala.Array}](${go(targ)}, implicitly)" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$encoderName(${go(targ)})" case TypesScala.Optional(targ) => code"$Encoder.encodeOption(${go(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$encoderName" diff --git a/typo/src/scala/typo/internal/codegen/JsonLibPlay.scala b/typo/src/scala/typo/internal/codegen/JsonLibPlay.scala index fe0965e8d8..c2806fc947 100644 --- a/typo/src/scala/typo/internal/codegen/JsonLibPlay.scala +++ b/typo/src/scala/typo/internal/codegen/JsonLibPlay.scala @@ -37,7 +37,7 @@ case class JsonLibPlay(pkg: sc.QIdent, default: ComputedDefault, inlineImplicits case TypesJava.OffsetDateTime => code"$Reads.DefaultOffsetDateTimeReads" case TypesJava.String => code"$Reads.StringReads" case TypesJava.UUID => code"$Reads.uuidReads" - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$Reads.ArrayReads[$targ](${go(targ)}, implicitly)" + case sc.Type.ArrayOf(targ) => code"$Reads.ArrayReads[$targ](${go(targ)}, implicitly)" case sc.Type.TApply(default.Defaulted, List(TypesScala.Optional(targ))) => code"${default.Defaulted}.$readsOptName(${go(targ)})" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$readsName(${go(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$readsName" @@ -67,7 +67,7 @@ case class JsonLibPlay(pkg: sc.QIdent, default: ComputedDefault, inlineImplicits case TypesJava.OffsetDateTime => code"$Writes.DefaultOffsetDateTimeWrites" case TypesJava.String => code"$Writes.StringWrites" case TypesJava.UUID => code"$Writes.UuidWrites" - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$Writes.arrayWrites[$targ](implicitly, ${go(targ)})" + case sc.Type.ArrayOf(targ) => code"$Writes.arrayWrites[$targ](implicitly, ${go(targ)})" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$writesName(${go(targ)})" case TypesScala.Optional(targ) => code"$Writes.OptionWrites(${go(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$writesName" diff --git a/typo/src/scala/typo/internal/codegen/JsonLibZioJson.scala b/typo/src/scala/typo/internal/codegen/JsonLibZioJson.scala index 50d91a4aa3..340bd9b480 100644 --- a/typo/src/scala/typo/internal/codegen/JsonLibZioJson.scala +++ b/typo/src/scala/typo/internal/codegen/JsonLibZioJson.scala @@ -33,7 +33,7 @@ final case class JsonLibZioJson(pkg: sc.QIdent, default: ComputedDefault, inline case TypesJava.OffsetTime => code"$JsonDecoder.offsetTime" case TypesJava.String => code"$JsonDecoder.string" case TypesJava.UUID => code"$JsonDecoder.uuid" - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$JsonDecoder.array[$targ](${go(targ)}, implicitly)" + case sc.Type.ArrayOf(targ) => code"$JsonDecoder.array[$targ](${go(targ)}, implicitly)" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$decoderName(${go(targ)})" case TypesScala.Optional(targ) => code"$JsonDecoder.option(${go(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$decoderName" @@ -62,7 +62,7 @@ final case class JsonLibZioJson(pkg: sc.QIdent, default: ComputedDefault, inline case TypesJava.OffsetTime => code"$JsonEncoder.offsetTime" case TypesJava.String => code"$JsonEncoder.string" case TypesJava.UUID => code"$JsonEncoder.uuid" - case sc.Type.TApply(TypesScala.Array, List(targ)) => code"$JsonEncoder.array[$targ](${go(targ)}, implicitly)" + case sc.Type.ArrayOf(targ) => code"$JsonEncoder.array[$targ](${go(targ)}, implicitly)" case sc.Type.TApply(default.Defaulted, List(targ)) => code"${default.Defaulted}.$encoderName(${go(targ)})" case TypesScala.Optional(targ) => code"$JsonEncoder.option(${go(targ)})" case x: sc.Type.Qualified if x.value.idents.startsWith(pkg.idents) => code"$tpe.$encoderName" diff --git a/typo/src/scala/typo/internal/codegen/addPackageAndImports.scala b/typo/src/scala/typo/internal/codegen/addPackageAndImports.scala index 3ac734fd56..bb2ba5dde5 100644 --- a/typo/src/scala/typo/internal/codegen/addPackageAndImports.scala +++ b/typo/src/scala/typo/internal/codegen/addPackageAndImports.scala @@ -86,6 +86,7 @@ object addPackageAndImports { // traverse type tree and rewrite qualified names def shortenNamesType(tpe: sc.Type, f: sc.Type.Qualified => sc.Type.Qualified): sc.Type = tpe match { + case sc.Type.ArrayOf(value) => sc.Type.ArrayOf(shortenNamesType(value, f)) case sc.Type.Abstract(value) => sc.Type.Abstract(value) case sc.Type.Wildcard => sc.Type.Wildcard case sc.Type.TApply(underlying, targs) => sc.Type.TApply(shortenNamesType(underlying, f), targs.map(targ => shortenNamesType(targ, f))) diff --git a/typo/src/scala/typo/internal/minimize.scala b/typo/src/scala/typo/internal/minimize.scala index 778351aaa2..f419ec8de2 100644 --- a/typo/src/scala/typo/internal/minimize.scala +++ b/typo/src/scala/typo/internal/minimize.scala @@ -52,6 +52,7 @@ object minimize { case sc.Type.TApply(underlying, targs) => goTree(underlying) targs.foreach(goTree) + case sc.Type.ArrayOf(value) => goTree(value) case sc.Type.Qualified(value) => goTree(value) case sc.Type.Abstract(_) => () case sc.Type.Commented(underlying, _) => goTree(underlying) diff --git a/typo/src/scala/typo/sc.scala b/typo/src/scala/typo/sc.scala index b1067b674d..4ff4f56cff 100644 --- a/typo/src/scala/typo/sc.scala +++ b/typo/src/scala/typo/sc.scala @@ -36,9 +36,7 @@ object sc { case class Param(name: Ident, tpe: Type, default: Option[sc.Code]) extends Tree case class Params(params: List[Param]) extends Tree - case class StrLit(str: String) extends Tree { - def prefixed(prefix: String) = StrLit(prefix + str) - } + case class StrLit(str: String) extends Tree case class StringInterpolate(`import`: sc.Type, prefix: sc.Ident, content: sc.Code) extends Tree @@ -87,6 +85,7 @@ object sc { case class Commented(underlying: Type, comment: String) extends Type case class UserDefined(underlying: Type) extends Type case class ByName(underlying: Type) extends Type + case class ArrayOf(underlying: Type) extends Type object Qualified { implicit val ordering: Ordering[Qualified] = scala.Ordering.by(x => x.dotName) @@ -156,6 +155,7 @@ object sc { .toMap def containsUserDefined(tpe: sc.Type): Boolean = tpe match { + case ArrayOf(targ) => containsUserDefined(targ) case Wildcard => false case TApply(underlying, targs) => containsUserDefined(underlying) || targs.exists(containsUserDefined) case Qualified(_) => false @@ -168,6 +168,7 @@ object sc { def base(tpe: sc.Type): sc.Type = tpe match { case Wildcard => tpe case TApply(underlying, targs) => TApply(base(underlying), targs.map(base)) + case ArrayOf(targ) => sc.Type.ArrayOf(base(targ)) case Qualified(_) => tpe case Abstract(_) => tpe case Commented(underlying, _) => base(underlying) @@ -258,6 +259,7 @@ object sc { case Summon(tpe) => s"implicitly[${renderTree(tpe)}]" case tpe: Type => tpe match { + case Type.ArrayOf(value) => s"Array[${renderTree(value)}]" case Type.Abstract(value) => renderTree(value) case Type.Wildcard => "?" case Type.TApply(underlying, targs) => renderTree(underlying) + targs.map(renderTree).mkString("[", ", ", "]")