Implement sounds like function for mysql

core/jvm/src/main/scala/zio/sql/ops/Operator.scala

@@ -52,7 +52,6 @@ object Operator {
  final case class OrBit[A: IsIntegral]() extends BinaryOp[A] {
  def isIntegral: IsIntegral[A] = implicitly[IsIntegral[A]]
  override val symbol: String = "|"
-
  }
  }
 
@@ -97,6 +96,12 @@ object Operator {
  case object Like extends RelationalOp {
  override val symbol: String = "like"
  }
+
+ object MySqlExtensions {
+ case object SoundsLike extends RelationalOp {
+ override val symbol: String = "sounds like"
+ }
+ }
  }
 
  sealed trait UnaryOp[A] extends Operator

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

@@ -1,12 +1,14 @@
 package zio.sql.mysql
 
-import java.time._
-import java.sql.ResultSet
-import java.util.UUID
-import zio.sql.Sql
-import zio.sql.select._
 import zio.sql.expr._
+import zio.sql.ops.Operator.RelationalOp
+import zio.sql.select._
 import zio.sql.typetag._
+import zio.sql.{ Features, Sql }
+
+import java.sql.ResultSet
+import java.time._
+import java.util.UUID
 
 trait MysqlSqlModule extends Sql { self =>
 
@@ -24,6 +26,17 @@ trait MysqlSqlModule extends Sql { self =>
  )
  }
  }
+
+ implicit class ExprOps[F1, A1, B](expr: Expr[F1, A1, B]) {
+ def soundsLike[F2, A2 <: A1](that: Expr[F2, A2, B])(implicit ev: B <:< String): Expr[F1 with F2, A2, Boolean] =
+ Expr.Relational(expr, that, RelationalOp.MySqlExtensions.SoundsLike)
+ }
+
+ implicit class LiteralOps[B](line: B)(implicit literal: B => Expr[Features.Literal, Any, B]) {
+ def soundsLike[F, A](that: Expr[F, A, B])(implicit
+ ev: B <:< String
+ ): Expr[Features.Literal with F, A, Boolean] = literal(line).soundsLike(that)
+ }
  }
 
  object MysqlFunctionDef {

mysql/src/test/resources/shop_schema.sql

@@ -48,7 +48,8 @@ values
  ('f76c9ace-be07-4bf3-bd4c-4a9c62882e64', 'Terrence', 'Noel', true, '1999-11-02'),
  ('784426a5-b90a-4759-afbb-571b7a0ba35e', 'Mila', 'Paterso', true, '1990-11-16'),
  ('df8215a2-d5fd-4c6c-9984-801a1b3a2a0b', 'Alana', 'Murray', true, '1995-11-12'),
- ('636ae137-5b1a-4c8c-b11f-c47c624d9cdc', 'Jose', 'Wiggins', false, '1987-03-23');
+ ('636ae137-5b1a-4c8c-b11f-c47c624d9cdc', 'Jose', 'Wiggins', false, '1987-03-23'),
+ ('d4f6c156-20ac-4d27-8ced-535bf4315ebc', 'Robert', 'Rupert', true, '1998-06-11');
 
 insert into products
  (id, name, description, image_url)

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

@@ -39,6 +39,7 @@ object CommonFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
  "RonaldRonaldRussell",
  "TerrenceTerrenceNoel",
  "MilaMilaPaterso",
+ "RobertRobertRupert",
  "AlanaAlanaMurray",
  "JoseJoseWiggins"
  )
@@ -54,6 +55,7 @@ object CommonFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
  "Person: Ronald Russell",
  "Person: Terrence Noel",
  "Person: Mila Paterso",
+ "Person: Robert Rupert",
  "Person: Alana Murray",
  "Person: Jose Wiggins"
  )
@@ -71,6 +73,7 @@ object CommonFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
  "Name: Ronald and Surname: Russell",
  "Name: Terrence and Surname: Noel",
  "Name: Mila and Surname: Paterso",
+ "Name: Robert and Surname: Rupert",
  "Name: Alana and Surname: Murray",
  "Name: Jose and Surname: Wiggins"
  )
@@ -95,7 +98,7 @@ object CommonFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
 
  val query = select(Concat(fName, lName) as "fullname") from customers
 
- val expected = Seq("RonaldRussell", "TerrenceNoel", "MilaPaterso", "AlanaMurray", "JoseWiggins")
+ val expected = Seq("RonaldRussell", "TerrenceNoel", "MilaPaterso", "RobertRupert", "AlanaMurray", "JoseWiggins")
 
  val result = execute(query)
 

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

@@ -1,17 +1,20 @@
 package zio.sql.mysql
 
-import zio.test._
-import zio.test.Assertion._
+import zio.Chunk
 import zio.schema._
-import java.time.{ LocalDate, LocalTime, ZoneId }
-import java.time.format.DateTimeFormatter
 import zio.sql.Jdbc
-import java.util.UUID
 import zio.sql.table._
+import zio.test.Assertion._
+import zio.test._
+
+import java.time.format.DateTimeFormatter
+import java.time.{ LocalDate, LocalTime, ZoneId }
+import java.util.UUID
 
 object CustomFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
 
  import MysqlFunctionDef._
+ import MysqlSpecific._
 
  case class Customers(id: UUID, dob: LocalDate, first_name: String, last_name: String, verified: Boolean)
 
@@ -120,6 +123,51 @@ object CustomFunctionDefSpec extends MysqlRunnableSpec with Jdbc {
 
  assertZIO(testResult.runHead.some)(equalTo(expected))
  },
+ test("sounds like") {
+ val query = select("Robert".soundsLike("Rupert"))
+
+ val testResult = execute(query)
+
+ assertZIO(testResult.runHead.some)(equalTo(true))
+ },
+ test("sounds like don't match") {
+ val query = select("Grisha".soundsLike("Berezin"))
+
+ val testResult = execute(query)
+
+ assertZIO(testResult.runHead.some)(equalTo(false))
+ },
+ test("sounds like don't match inverse") {
+ val query = select("Grisha".soundsLike("Berezin").isNotTrue)
+
+ val testResult = execute(query)
+
+ assertZIO(testResult.runHead.some)(equalTo(true))
+ },
+ test("sounds like on column") {
+ val query = select(customerId).from(customers).where(fName.soundsLike(lName))
+
+ for {
+ result <- execute(query).runCollect
+ } yield assertTrue(
+ result == Chunk(UUID.fromString("d4f6c156-20ac-4d27-8ced-535bf4315ebc"))
+ )
+ },
+ test("sounds like on column inverse") {
+ val query = select(customerId).from(customers).where(fName.soundsLike(lName).isNotTrue)
+
+ for {
+ result <- execute(query).runCollect
+ } yield assertTrue(
+ result == Chunk(
+ UUID.fromString("60b01fc9-c902-4468-8d49-3c0f989def37"),
+ UUID.fromString("636ae137-5b1a-4c8c-b11f-c47c624d9cdc"),
+ UUID.fromString("784426a5-b90a-4759-afbb-571b7a0ba35e"),
+ UUID.fromString("df8215a2-d5fd-4c6c-9984-801a1b3a2a0b"),
+ UUID.fromString("f76c9ace-be07-4bf3-bd4c-4a9c62882e64")
+ )
+ )
+ },
  test("current_date") {
  val query = select(CurrentDate)
 

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

@@ -83,8 +83,6 @@ object MysqlModuleSpec extends MysqlRunnableSpec {
 
  val query = select(customerId, fName, lName, dob) from customers
 
- println(renderRead(query))
-
  val expected =
  Seq(
  Customer(
@@ -116,6 +114,12 @@ object MysqlModuleSpec extends MysqlRunnableSpec {
  "Jose",
  "Wiggins",
  LocalDate.parse("1987-03-23")
+ ),
+ Customer(
+ UUID.fromString("d4f6c156-20ac-4d27-8ced-535bf4315ebc"),
+ "Robert",
+ "Rupert",
+ LocalDate.parse("1998-06-11")
  )
  )
 
@@ -186,6 +190,7 @@ object MysqlModuleSpec extends MysqlRunnableSpec {
  UUID.fromString("60b01fc9-c902-4468-8d49-3c0f989def37"),
  UUID.fromString("f76c9ace-be07-4bf3-bd4c-4a9c62882e64"),
  UUID.fromString("784426a5-b90a-4759-afbb-571b7a0ba35e"),
+ UUID.fromString("d4f6c156-20ac-4d27-8ced-535bf4315ebc"),
  UUID.fromString("df8215a2-d5fd-4c6c-9984-801a1b3a2a0b"),
  UUID.fromString("636ae137-5b1a-4c8c-b11f-c47c624d9cdc")
  )
@@ -200,6 +205,7 @@ object MysqlModuleSpec extends MysqlRunnableSpec {
  UUID.fromString("60b01fc9-c902-4468-8d49-3c0f989def37"),
  UUID.fromString("f76c9ace-be07-4bf3-bd4c-4a9c62882e64"),
  UUID.fromString("784426a5-b90a-4759-afbb-571b7a0ba35e"),
+ UUID.fromString("d4f6c156-20ac-4d27-8ced-535bf4315ebc"),
  UUID.fromString("df8215a2-d5fd-4c6c-9984-801a1b3a2a0b"),
  UUID.fromString("636ae137-5b1a-4c8c-b11f-c47c624d9cdc")
  )
@@ -215,7 +221,7 @@ object MysqlModuleSpec extends MysqlRunnableSpec {
 
  for {
  r <- execute(query).runCollect
- } yield assertTrue(r.head == 5L)
+ } yield assertTrue(r.head == 6L)
  },
  test("Can select from joined tables (inner join)") {
  val query = select(fName, lName, orderDate) from (customers join orders).on(

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

@@ -32,7 +32,7 @@ object TransactionSpec extends MysqlRunnableSpec with Jdbc {
 
  val assertion =
  result
- .map(count => assertTrue(count == 5))
+ .map(count => assertTrue(count == 6))
  .orDie
 
  assertion.mapErrorCause(cause => Cause.stackless(cause.untraced))
@@ -49,7 +49,7 @@ object TransactionSpec extends MysqlRunnableSpec with Jdbc {
  remainingCustomersCount <- execute(query).map(identity[UUID](_)).runCount
  } yield (allCustomersCount, remainingCustomersCount))
 
- assertZIO(result)(equalTo((5L, 5L))).mapErrorCause(cause => Cause.stackless(cause.untraced))
+ assertZIO(result)(equalTo((6L, 6L))).mapErrorCause(cause => Cause.stackless(cause.untraced))
  },
  test("Transaction succeeded and deleted rows") {
  val query = select(customerId) from customers
@@ -63,7 +63,7 @@ object TransactionSpec extends MysqlRunnableSpec with Jdbc {
  remainingCustomersCount <- execute(query).map(identity[UUID](_)).runCount
  } yield (allCustomersCount, remainingCustomersCount))
 
- assertZIO(result)(equalTo((5L, 4L))).mapErrorCause(cause => Cause.stackless(cause.untraced))
+ assertZIO(result)(equalTo((6L, 5L))).mapErrorCause(cause => Cause.stackless(cause.untraced))
  }
  ) @@ sequential
 }