Handle postgres error code 42P08 among the lazyly rewritten prepared statements with parameters. Also similar tests have been refactored to use the eventually close and ensure the connection is closed on a test failure as well.

fixes #1103

Author: vietj

vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgSocketConnection.java

@@ -167,7 +167,7 @@ protected <R> void doSchedule(CommandBase<R> cmd, Handler<AsyncResult<R>> handle
   public boolean isIndeterminatePreparedStatementError(Throwable error) {
     if (error instanceof PgException) {
       String code = ((PgException) error).getCode();
-      return "42P18".equals(code) || "42804".equals(code);
+      return "42P18".equals(code) || "42804".equals(code) || "42P08".equals(code);
     }
     return false;
   }

vertx-pg-client/src/test/java/io/vertx/pgclient/PreparedStatementTestBase.java

@@ -343,197 +343,216 @@ public void testCloseStatement(TestContext ctx) {
   }
 
   @Test
-  public void testInferDataTypeString(TestContext ctx) {
-    testInferDataType(ctx, String.class, "WORLD", "WORLD");
+  public void testInferDataTypeString42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, String.class, "WORLD", "WORLD");
   }
 
   @Test
-  public void testInferDataTypeBoolean(TestContext ctx) {
-    testInferDataType(ctx, Boolean.class, true, "t");
+  public void testInferDataTypeBoolean42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Boolean.class, true, "t");
   }
 
   @Test
-  public void testInferDataTypeShort(TestContext ctx) {
-    testInferDataType(ctx, Short.class, (short)2, "2");
+  public void testInferDataTypeShort42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Short.class, (short)2, "2");
   }
 
   @Test
-  public void testInferDataTypeInteger(TestContext ctx) {
-    testInferDataType(ctx, Integer.class, Integer.MAX_VALUE, "" + Integer.MAX_VALUE);
+  public void testInferDataTypeInteger42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Integer.class, Integer.MAX_VALUE, "" + Integer.MAX_VALUE);
   }
 
   @Test
-  public void testInferDataTypeLong(TestContext ctx) {
-    testInferDataType(ctx, Long.class, Long.MAX_VALUE, "" + Long.MAX_VALUE);
+  public void testInferDataTypeLong42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Long.class, Long.MAX_VALUE, "" + Long.MAX_VALUE);
   }
 
   @Test
-  public void testInferDataTypeFloat(TestContext ctx) {
-    testInferDataType(ctx, Float.class, 0F, "0");
+  public void testInferDataTypeFloat42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Float.class, 0F, "0");
   }
 
   @Test
-  public void testInferDataTypeDouble(TestContext ctx) {
-    testInferDataType(ctx, Double.class, 0D, "0");
+  public void testInferDataTypeDouble42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Double.class, 0D, "0");
   }
 
   @Test
-  public void testInferDataTypeLocalDate(TestContext ctx) {
+  public void testInferDataTypeLocalDate42P18(TestContext ctx) {
     LocalDate value = LocalDate.now();
-    testInferDataType(ctx, LocalDate.class, value, value.toString());
+    testInferDataType42P18(ctx, LocalDate.class, value, value.toString());
   }
 
   @Test
-  public void testInferDataTypeLocalDateTime(TestContext ctx) {
+  public void testInferDataTypeLocalDateTime42P18(TestContext ctx) {
     LocalDateTime value = LocalDateTime.of(LocalDate.now(), LocalTime.NOON);
     String suffix = value.toLocalDate() + " " + value.toLocalTime().format(DateTimeFormatter.ISO_LOCAL_TIME);
-    testInferDataType(ctx, LocalDateTime.class, value, suffix, "{\"" + suffix + "\"}");
+    testInferDataType42P18(ctx, LocalDateTime.class, value, suffix, "{\"" + suffix + "\"}");
   }
 
   @Test
-  public void testInferDataTypeOffsetDateTime(TestContext ctx) {
+  public void testInferDataTypeOffsetDateTime42P18(TestContext ctx) {
     OffsetDateTime value = OffsetDateTime.of(LocalDateTime.of(LocalDate.now(), LocalTime.NOON), ZoneOffset.UTC);
     String suffix = value.toLocalDate() + " " + value.toLocalTime().format(DateTimeFormatter.ISO_LOCAL_TIME) + "+00";
-    testInferDataType(ctx, OffsetDateTime.class, value, suffix, "{\"" + suffix + "\"}");
+    testInferDataType42P18(ctx, OffsetDateTime.class, value, suffix, "{\"" + suffix + "\"}");
   }
 
   @Test
-  public void testInferDataTypeOffsetInterval(TestContext ctx) {
+  public void testInferDataTypeOffsetInterval42P18(TestContext ctx) {
     Interval value = Interval.of(1);
-    testInferDataType(ctx, Interval.class, value, "1 year", "{\"1 year\"}");
+    testInferDataType42P18(ctx, Interval.class, value, "1 year", "{\"1 year\"}");
   }
 
   @Test
-  public void testInferDataTypeBuffer(TestContext ctx) {
-    testInferDataType(ctx, Buffer.class, Buffer.buffer("WORLD"), "\\x574f524c44", "{\"\\\\x574f524c44\"}");
+  public void testInferDataTypeBuffer42P18(TestContext ctx) {
+    testInferDataType42P18(ctx, Buffer.class, Buffer.buffer("WORLD"), "\\x574f524c44", "{\"\\\\x574f524c44\"}");
   }
 
   @Test
-  public void testInferDataTypeUUID(TestContext ctx) {
+  public void testInferDataTypeUUID42P18(TestContext ctx) {
     UUID value = UUID.randomUUID();
-    testInferDataType(ctx, UUID.class, value, "" + value);
+    testInferDataType42P18(ctx, UUID.class, value, "" + value);
   }
 
   @Test
-  public void testInferDataTypeJsonObject(TestContext ctx) {
+  public void testInferDataTypeJsonObject42P18(TestContext ctx) {
     JsonObject value = new JsonObject().put("foo", "bar");
-    testInferDataType(ctx, JsonObject.class, value, "" + value, "{\"{\\\"foo\\\":\\\"bar\\\"}\"}");
+    testInferDataType42P18(ctx, JsonObject.class, value, "" + value, "{\"{\\\"foo\\\":\\\"bar\\\"}\"}");
   }
 
   @Test
-  public void testInferDataTypeJsonArray(TestContext ctx) {
+  public void testInferDataTypeJsonArray42P18(TestContext ctx) {
     JsonArray value = new JsonArray().add(1).add("foo").add(true);
-    testInferDataType(ctx, JsonArray.class, value, "" + value, "{\"[1,\\\"foo\\\",true]\"}");
+    testInferDataType42P18(ctx, JsonArray.class, value, "" + value, "{\"[1,\\\"foo\\\",true]\"}");
   }
 
   @Test
-  public void testInferDataTypePoint(TestContext ctx) {
+  public void testInferDataTypePoint42P18(TestContext ctx) {
     Point value = new Point();
-    testInferDataType(ctx, Point.class, value, "(0,0)", "{\"(0,0)\"}");
+    testInferDataType42P18(ctx, Point.class, value, "(0,0)", "{\"(0,0)\"}");
   }
 
   @Test
-  public void testInferDataTypeLine(TestContext ctx) {
+  public void testInferDataTypeLine42P18(TestContext ctx) {
     Line value = new Line(1.0, 0.0, 0.0);
-    testInferDataType(ctx, Line.class, value, "{1,0,0}", "{\"{1,0,0}\"}");
+    testInferDataType42P18(ctx, Line.class, value, "{1,0,0}", "{\"{1,0,0}\"}");
   }
 
   @Test
-  public void testInferDataTypeLineSegment(TestContext ctx) {
+  public void testInferDataTypeLineSegment42P18(TestContext ctx) {
     LineSegment value = new LineSegment();
-    testInferDataType(ctx, LineSegment.class, value, "[(0,0),(0,0)]", "{\"[(0,0),(0,0)]\"}");
+    testInferDataType42P18(ctx, LineSegment.class, value, "[(0,0),(0,0)]", "{\"[(0,0),(0,0)]\"}");
   }
 
   @Test
-  public void testInferDataTypeBox(TestContext ctx) {
+  public void testInferDataTypeBox42P18(TestContext ctx) {
     Box value = new Box();
-    testInferDataType(ctx, Box.class, value, "(0,0),(0,0)");
+    testInferDataType42P18(ctx, Box.class, value, "(0,0),(0,0)");
   }
 
   @Test
-  public void testInferDataTypePath(TestContext ctx) {
+  public void testInferDataTypePath42P18(TestContext ctx) {
     Path value = new Path().addPoint(new Point());
-    testInferDataType(ctx, Path.class, value, "((0,0))", "{\"((0,0))\"}");
+    testInferDataType42P18(ctx, Path.class, value, "((0,0))", "{\"((0,0))\"}");
   }
 
   @Test
-  public void testInferDataTypePolygon(TestContext ctx) {
+  public void testInferDataTypePolygon42P18(TestContext ctx) {
     Polygon value = new Polygon().addPoint(new Point()).addPoint(new Point()).addPoint(new Point());
-    testInferDataType(ctx, Polygon.class, value, "((0,0),(0,0),(0,0))", "{\"((0,0),(0,0),(0,0))\"}");
+    testInferDataType42P18(ctx, Polygon.class, value, "((0,0),(0,0),(0,0))", "{\"((0,0),(0,0),(0,0))\"}");
   }
 
   @Test
-  public void testInferDataTypeCircle(TestContext ctx) {
+  public void testInferDataTypeCircle42P18(TestContext ctx) {
     Circle value = new Circle();
-    testInferDataType(ctx, Circle.class, value, "<(0,0),0>", "{\"<(0,0),0>\"}");
+    testInferDataType42P18(ctx, Circle.class, value, "<(0,0),0>", "{\"<(0,0),0>\"}");
   }
 
-  private <T> void testInferDataType(TestContext ctx, Class<T> type, T value, String suffix) {
-    testInferDataType(ctx, type, value, suffix, "{" + suffix + "}");
+  private <T> void testInferDataType42P18(TestContext ctx, Class<T> type, T value, String suffix) {
+    testInferDataType42P18(ctx, type, value, suffix, "{" + suffix + "}");
   }
 
-  private <T> void testInferDataType(TestContext ctx, Class<T> type, T value, String suffix1, String suffix2) {
+  private <T> void testInferDataType42P18(TestContext ctx, Class<T> type, T value, String suffix1, String suffix2) {
+    Object array = Array.newInstance(type, 1);
+    Array.set(array, 0, value);
     PgConnection.connect(vertx, options(), ctx.asyncAssertSuccess(conn -> {
-      conn.preparedQuery("SELECT CONCAT('HELLO ', $1)")
-        .execute(Tuple.of(value), ctx.asyncAssertSuccess(result1 -> {
+      conn
+        .preparedQuery("SELECT CONCAT('HELLO ', $1)").execute(Tuple.of(value))
+        .map(result1 -> {
           Row row1 = result1.iterator().next();
           ctx.assertEquals("HELLO " + suffix1, row1.getString(0));
-          Object array = Array.newInstance(type, 1);
-          Array.set(array, 0, value);
-          conn.preparedQuery("SELECT CONCAT('HELLO ', $1)")
-            .execute(Tuple.of(array), ctx.asyncAssertSuccess(result2 -> {
-              Row row2 = result2.iterator().next();
-              String v = row2.getString(0);
-              ctx.assertEquals("HELLO " + suffix2, row2.getString(0));
-              conn.close();
-            }));
-        }));
+          return "";
+        })
+        .compose(v -> conn.preparedQuery("SELECT CONCAT('HELLO ', $1)").execute(Tuple.of(array)))
+        .map(result2 -> {
+          Row row2 = result2.iterator().next();
+          String v = row2.getString(0);
+          ctx.assertEquals("HELLO " + suffix2, row2.getString(0));
+          return "";
+        })
+        .eventually(v -> conn.close());
     }));
   }
 
   @Test
-  public void testInferDataTypeFailure(TestContext ctx) {
+  public void testInferDataTypeLazy42P18(TestContext ctx) {
     PgConnection.connect(vertx, options(), ctx.asyncAssertSuccess(conn -> {
-      conn.preparedQuery("SELECT CONCAT('HELLO', $1)")
-        .execute(Tuple.of(null), ctx.asyncAssertFailure(result -> {
-          conn.close();
-        }));
+      conn
+        .prepare("SELECT CONCAT('HELLO', $1)")
+        .compose(ps -> ps.query().execute(Tuple.of("__")))
+        .map(result -> {
+          Row row = result.iterator().next();
+          ctx.assertEquals("HELLO__", row.getString(0));
+          return "";
+        })
+        .eventually(v -> conn.close());
     }));
   }
 
   @Test
-  public void testInferDataTypeLazy(TestContext ctx) {
+  public void testInferDataTypeFailure42P18(TestContext ctx) {
     PgConnection.connect(vertx, options(), ctx.asyncAssertSuccess(conn -> {
-      conn.prepare("SELECT CONCAT('HELLO', $1)", ctx.asyncAssertSuccess(ps -> {
-        ps.query().execute(Tuple.of("__"), ctx.asyncAssertSuccess(result -> {
-          Row row = result.iterator().next();
-          ctx.assertEquals("HELLO__", row.getString(0));
-          conn.close();
-        }));
-      }));
+      conn.preparedQuery("SELECT CONCAT('HELLO', $1)")
+        .execute(Tuple.of(null))
+        .eventually(v -> conn.close())
+        .onComplete(ctx.asyncAssertFailure());
     }));
   }
 
   @Test
-  public void testInferDataTypeLazyFailure(TestContext ctx) {
+  public void testInferDataTypeLazyFailure42P18(TestContext ctx) {
     PgConnection.connect(vertx, options(), ctx.asyncAssertSuccess(conn -> {
-      conn.prepare("SELECT CONCAT('HELLO', $1)", ctx.asyncAssertSuccess(ps -> {
-        ps.query().execute(Tuple.of(null), ctx.asyncAssertFailure(result -> {
-          conn.close();
-        }));
-      }));
+      conn
+        .prepare("SELECT CONCAT('HELLO', $1)")
+        .compose(ps -> ps.query().execute(Tuple.of(null)))
+        .eventually(v -> conn.close())
+        .onComplete(ctx.asyncAssertFailure());
     }));
   }
 
   @Test
-  public void testInferDataTypeLazyPolymorphic(TestContext ctx) {
+  public void testInferDataTypeLazy42804(TestContext ctx) {
     PgConnection.connect(vertx, options(), ctx.asyncAssertSuccess(conn -> {
-      conn.prepare("SELECT to_jsonb($1)", ctx.asyncAssertSuccess(ps -> {
-        ps.query().execute(Tuple.of("foo"), ctx.asyncAssertSuccess(result -> {
+      conn
+        .prepare("SELECT to_jsonb($1)")
+        .compose(ps -> ps.query().execute(Tuple.of("foo")))
+        .map(result -> {
           ctx.assertEquals("foo", result.iterator().next().getString(0));
-          conn.close();
-        }));
-      }));
+          return "";
+        })
+        .eventually(v -> conn.close())
+        .onComplete(ctx.asyncAssertSuccess());
+    }));
+  }
+
+  @Test
+  public void testInferDataTypeLazy42P08(TestContext ctx) {
+    PgConnection.connect(vertx, options(), ctx.asyncAssertSuccess(conn -> {
+      conn
+        .prepare("UPDATE Fortune SET message=$2 WHERE id=$1 AND (Fortune.*) IS DISTINCT FROM ($1, $2)")
+        .compose(ps -> ps.query().execute(Tuple.of(9, "Feature: A bug with seniority.")))
+        .eventually(v -> conn.close())
+        .onComplete(ctx.asyncAssertSuccess());
     }));
   }
 }