rename method, ignore NoticeResponse, update tests

modules/core/shared/src/main/scala/Session.scala

@@ -196,10 +196,10 @@ trait Session[F[_]] {
   def execute[A](command: Command[A], args: A)(implicit ev: DummyImplicit): F[Completion] = execute(command)(args)
 
   /**
-   * Execute any non-parameterized statement containing single or multi-query statements.
-   * Discard returned completitions and rows.
+   * Execute any non-parameterized statement containing single or multi-query statements,
+   * discarding returned completions and rows.
    */
-  def execute_(statement: Statement[Void]): F[Unit]
+  def executeDiscard(statement: Statement[Void]): F[Unit]
 
   /**
    * Prepares then caches a query, yielding a `PreparedQuery` which can be executed multiple
@@ -629,8 +629,8 @@ object Session {
         override def execute(command: Command[Void]): F[Completion] =
           proto.execute(command)
 
-        override def execute_(statement: Statement[Void]): F[Unit] =
-          proto.execute_(statement)
+        override def executeDiscard(statement: Statement[Void]): F[Unit] =
+          proto.executeDiscard(statement)
 
         override def channel(name: Identifier): Channel[F, String, String] =
           Channel.fromNameAndProtocol(name, proto)
@@ -710,7 +710,7 @@ object Session {
 
         override def execute(command: Command[Void]): G[Completion] = fk(outer.execute(command))
 
-        override def execute_(statement: Statement[Void]): G[Unit] = fk(outer.execute_(statement))
+        override def executeDiscard(statement: Statement[Void]): G[Unit] = fk(outer.executeDiscard(statement))
 
         override def execute[A](query: Query[Void,A]): G[List[A]] = fk(outer.execute(query))
 

modules/core/shared/src/main/scala/net/Protocol.scala

@@ -89,10 +89,10 @@ trait Protocol[F[_]] {
   def execute[A](query: Query[Void, A], ty: Typer): F[List[A]]
 
   /**
-   * Execute any non-parameterized statement containing single or multi-query statements.
-   * Discard returned completitions and rows.
+   * Execute any non-parameterized statement containing single or multi-query statements, 
+   * discarding returned completions and rows.
    */
-  def execute_(statement: Statement[Void]): F[Unit]
+  def executeDiscard(statement: Statement[Void]): F[Unit]
 
   /**
    * Initiate the session. This must be the first thing you do. This is very basic at the moment.
@@ -252,7 +252,7 @@ object Protocol {
         override def execute[B](query: Query[Void, B], ty: Typer): F[List[B]] =
           protocol.Query[F](redactionStrategy).apply(query, ty)
 
-        override def execute_(statement: Statement[Void]): F[Unit] = protocol.Query[F](redactionStrategy).apply_(statement)
+        override def executeDiscard(statement: Statement[Void]): F[Unit] = protocol.Query[F](redactionStrategy).applyDiscard(statement)
 
         override def startup(user: String, database: String, password: Option[String], parameters: Map[String, String]): F[Unit] =
           protocol.Startup[F].apply(user, database, password, parameters)

modules/core/shared/src/main/scala/net/protocol/Query.scala

@@ -23,7 +23,7 @@ import skunk.exception.EmptyStatementException
 trait Query[F[_]] {
   def apply(command: Command[Void]): F[Completion]
   def apply[B](query: skunk.Query[Void, B], ty: Typer): F[List[B]]
-  def apply_(statement: Statement[Void]): F[Unit]
+  def applyDiscard(statement: Statement[Void]): F[Unit]
 }
 
 object Query {
@@ -222,20 +222,9 @@ object Query {
             case Some(e) => e.raiseError[F, Unit]
           }
 
-          case RowDescription(_) | RowData(_) | CommandComplete(_) | EmptyQueryResponse =>
+          case RowDescription(_) | RowData(_) | CommandComplete(_) | EmptyQueryResponse | NoticeResponse(_) =>
             finishUpDiscard(stmt, error)
 
-          case NoticeResponse(info) =>
-            error match {
-              case None =>
-                for {
-                  hi <- history(Int.MaxValue)
-                  err = new PostgresErrorException(stmt.sql, Some(stmt.origin), info, hi)
-                  c <- finishUpDiscard(stmt, Some(err))
-                } yield c
-              case _ => finishUpDiscard(stmt, error)
-            }
-
           case ErrorResponse(info) =>
             error match {
               case None =>
@@ -258,7 +247,7 @@ object Query {
             finishCopyOut *> finishUpDiscard(stmt, error.orElse(new CopyNotSupportedException(stmt).some))
         }
 
-      override def apply_(statement: Statement[Void]): F[Unit] =
+      override def applyDiscard(statement: Statement[Void]): F[Unit] =
         exchange("query") { (span: Span[F]) =>
           span.addAttribute(
             Attribute("command.sql", statement.sql)

modules/tests/shared/src/test/scala/MultipleStatementsTest.scala

@@ -23,17 +23,23 @@ class MultipleStatementsTest extends SkunkTest {
   statements.foreach { case (q, c, any) =>
     sessionTest(s"query: ${q.sql}") { s =>  s.execute(q).assertFailsWith[SkunkException] *> s.assertHealthy }
     sessionTest(s"command: ${c.sql}") { s =>  s.execute(c).assertFailsWith[SkunkException] *> s.assertHealthy }
-    sessionTest(s"any discarded: ${any.sql}") { s =>  s.execute_(any).assertFailsWith[CopyNotSupportedException] *> s.assertHealthy }
+    sessionTest(s"any discarded: ${any.sql}") { s =>  s.executeDiscard(any).assertFailsWith[CopyNotSupportedException] *> s.assertHealthy }
   }
 
   // statements with no errors
-  List("select 1","commit","/* empty */")
+  List(
+    """CREATE FUNCTION do_something() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql;
+       SELECT do_something();
+       DROP FUNCTION do_something""", // query + command
+    "select 1", // query
+    "commit", // command
+    "/* empty */")
     .permutations
     .toList
     .map(s => sql"#${s.intercalate(";")}".command)
     .foreach { stmt =>
       sessionTest(s"discarded no errors: ${stmt.sql}") { s =>
-        s.execute_(stmt) *> s.assertHealthy
+        s.executeDiscard(stmt) *> s.assertHealthy
       }
     }
 
@@ -50,11 +56,11 @@ class MultipleStatementsTest extends SkunkTest {
 
       if (statements.indexOf(conflict) < statements.indexOf(copy))
         sessionTest(s"discarded with postgres error: ${stmt.sql}")(s => 
-          s.execute_(stmt).assertFailsWith[PostgresErrorException] *> s.assertHealthy
+          s.executeDiscard(stmt).assertFailsWith[PostgresErrorException] *> s.assertHealthy
         )
       else
         sessionTest(s"discarded with unsupported error: ${stmt.sql}")(s =>
-          s.execute_(stmt).assertFailsWith[CopyNotSupportedException] *> s.assertHealthy
+          s.executeDiscard(stmt).assertFailsWith[CopyNotSupportedException] *> s.assertHealthy
         )
     }
   }