From 52cfbfcda7e88faffc80026ffba1cd93bf05a3f2 Mon Sep 17 00:00:00 2001 From: "release-please[bot]" <55107282+release-please[bot]@users.noreply.github.com> Date: Thu, 4 Jul 2024 17:09:49 +0200 Subject: [PATCH 01/20] chore(main): release 2.20.2-SNAPSHOT (#1674) Co-authored-by: release-please[bot] <55107282+release-please[bot]@users.noreply.github.com> --- pom.xml | 2 +- samples/snapshot/pom.xml | 2 +- versions.txt | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/pom.xml b/pom.xml index 90c0bc999..064e0313f 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 google-cloud-spanner-jdbc - 2.20.1 + 2.20.2-SNAPSHOT jar Google Cloud Spanner JDBC https://github.com/googleapis/java-spanner-jdbc diff --git a/samples/snapshot/pom.xml b/samples/snapshot/pom.xml index edd0343b6..e173442f4 100644 --- a/samples/snapshot/pom.xml +++ b/samples/snapshot/pom.xml @@ -28,7 +28,7 @@ com.google.cloud google-cloud-spanner-jdbc - 2.20.1 + 2.20.2-SNAPSHOT diff --git a/versions.txt b/versions.txt index 3ba0302dd..807395b03 100644 --- a/versions.txt +++ b/versions.txt @@ -1,4 +1,4 @@ # Format: # module:released-version:current-version -google-cloud-spanner-jdbc:2.20.1:2.20.1 +google-cloud-spanner-jdbc:2.20.1:2.20.2-SNAPSHOT From f6ad8737f7b5612992a7321165fb35c0cec5d7fb Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Sat, 6 Jul 2024 19:18:30 +0200 Subject: [PATCH 02/20] chore(deps): update dependency com.google.cloud:google-cloud-spanner-jdbc to v2.20.1 (#1675) --- samples/install-without-bom/pom.xml | 2 +- samples/spring-data-jdbc/pom.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/samples/install-without-bom/pom.xml b/samples/install-without-bom/pom.xml index d21942051..94307f836 100644 --- a/samples/install-without-bom/pom.xml +++ b/samples/install-without-bom/pom.xml @@ -29,7 +29,7 @@ com.google.cloud google-cloud-spanner-jdbc - 2.20.0 + 2.20.1 diff --git a/samples/spring-data-jdbc/pom.xml b/samples/spring-data-jdbc/pom.xml index c81835b51..bf354299e 100644 --- a/samples/spring-data-jdbc/pom.xml +++ b/samples/spring-data-jdbc/pom.xml @@ -62,7 +62,7 @@ com.google.cloud google-cloud-spanner-jdbc - 2.20.0 + 2.20.1 org.postgresql From 4c9a3f2eae6d33c50851bab8c9694eb3a87bf81a Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 9 Jul 2024 07:30:58 +0200 Subject: [PATCH 03/20] chore(deps): update dependency com.google.cloud:libraries-bom to v26.43.0 (#1677) --- samples/snippets/pom.xml | 2 +- samples/spring-data-jdbc/pom.xml | 2 +- samples/spring-data-mybatis/pom.xml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/samples/snippets/pom.xml b/samples/snippets/pom.xml index a7c189c45..0c3b12de9 100644 --- a/samples/snippets/pom.xml +++ b/samples/snippets/pom.xml @@ -26,7 +26,7 @@ com.google.cloud libraries-bom - 26.42.0 + 26.43.0 pom import diff --git a/samples/spring-data-jdbc/pom.xml b/samples/spring-data-jdbc/pom.xml index bf354299e..adfc3dd38 100644 --- a/samples/spring-data-jdbc/pom.xml +++ b/samples/spring-data-jdbc/pom.xml @@ -37,7 +37,7 @@ com.google.cloud libraries-bom - 26.42.0 + 26.43.0 import pom diff --git a/samples/spring-data-mybatis/pom.xml b/samples/spring-data-mybatis/pom.xml index f2adc315e..db5af5419 100644 --- a/samples/spring-data-mybatis/pom.xml +++ b/samples/spring-data-mybatis/pom.xml @@ -35,7 +35,7 @@ com.google.cloud libraries-bom - 26.42.0 + 26.43.0 import pom From faf7c4908a926cd7a10ea0b860babcaa97c4c7e1 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 9 Jul 2024 07:51:51 +0200 Subject: [PATCH 04/20] deps: update dependency io.opentelemetry:opentelemetry-bom to v1.40.0 (#1676) --- samples/spring-data-jdbc/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/samples/spring-data-jdbc/pom.xml b/samples/spring-data-jdbc/pom.xml index adfc3dd38..f65c69112 100644 --- a/samples/spring-data-jdbc/pom.xml +++ b/samples/spring-data-jdbc/pom.xml @@ -44,7 +44,7 @@ io.opentelemetry opentelemetry-bom - 1.39.0 + 1.40.0 pom import From ddf47f4fc7e1c05e6e3086ada0ff3b2c1efeb2af Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Fri, 12 Jul 2024 09:46:35 +0200 Subject: [PATCH 05/20] deps: update dependency com.google.cloud.opentelemetry:exporter-trace to v0.31.0 (#1679) --- pom.xml | 2 +- samples/spring-data-jdbc/pom.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 064e0313f..c8d66c0d1 100644 --- a/pom.xml +++ b/pom.xml @@ -232,7 +232,7 @@ com.google.cloud.opentelemetry exporter-trace - 0.30.0 + 0.31.0 test diff --git a/samples/spring-data-jdbc/pom.xml b/samples/spring-data-jdbc/pom.xml index f65c69112..5990abbde 100644 --- a/samples/spring-data-jdbc/pom.xml +++ b/samples/spring-data-jdbc/pom.xml @@ -78,7 +78,7 @@ com.google.cloud.opentelemetry exporter-trace - 0.30.0 + 0.31.0 From 7d17ec761c182d08e738cafc72b7618799ff13bd Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Sun, 14 Jul 2024 08:10:12 +0200 Subject: [PATCH 06/20] test(deps): update dependency com.google.truth:truth to v1.4.4 (#1682) --- samples/install-without-bom/pom.xml | 2 +- samples/snapshot/pom.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/samples/install-without-bom/pom.xml b/samples/install-without-bom/pom.xml index 94307f836..87be572f4 100644 --- a/samples/install-without-bom/pom.xml +++ b/samples/install-without-bom/pom.xml @@ -42,7 +42,7 @@ com.google.truth truth - 1.4.3 + 1.4.4 test diff --git a/samples/snapshot/pom.xml b/samples/snapshot/pom.xml index e173442f4..cc99c9b5e 100644 --- a/samples/snapshot/pom.xml +++ b/samples/snapshot/pom.xml @@ -41,7 +41,7 @@ com.google.truth truth - 1.4.3 + 1.4.4 test From 23934f7f38f5c99b7a6859ab69525ce368317128 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Sun, 14 Jul 2024 08:11:16 +0200 Subject: [PATCH 07/20] deps: update dependency org.springframework.data:spring-data-bom to v2024.0.2 (#1680) --- samples/spring-data-jdbc/pom.xml | 2 +- samples/spring-data-mybatis/pom.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/samples/spring-data-jdbc/pom.xml b/samples/spring-data-jdbc/pom.xml index 5990abbde..0d9e94c96 100644 --- a/samples/spring-data-jdbc/pom.xml +++ b/samples/spring-data-jdbc/pom.xml @@ -23,7 +23,7 @@ org.springframework.data spring-data-bom - 2024.0.1 + 2024.0.2 import pom diff --git a/samples/spring-data-mybatis/pom.xml b/samples/spring-data-mybatis/pom.xml index db5af5419..b9fe2a929 100644 --- a/samples/spring-data-mybatis/pom.xml +++ b/samples/spring-data-mybatis/pom.xml @@ -28,7 +28,7 @@ org.springframework.data spring-data-bom - 2024.0.1 + 2024.0.2 import pom From 6bb0a6d813b5db6629a83ab43e5eac155acb7913 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Sun, 14 Jul 2024 08:11:29 +0200 Subject: [PATCH 08/20] test(deps): update dependency com.google.truth:truth to v1.4.4 (#1681) --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index c8d66c0d1..a8141a84b 100644 --- a/pom.xml +++ b/pom.xml @@ -51,7 +51,7 @@ google-cloud-spanner-jdbc 4.13.2 3.0.2 - 1.4.3 + 1.4.4 4.11.0 2.2 0.31.1 From 98bf7c6367ec697dda7a4778b778399fd6d59c9e Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 16 Jul 2024 20:50:13 +0200 Subject: [PATCH 09/20] build(deps): update dependency org.apache.maven.plugins:maven-project-info-reports-plugin to v3.6.2 (#1683) --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index a8141a84b..9cece1c6b 100644 --- a/pom.xml +++ b/pom.xml @@ -439,7 +439,7 @@ org.apache.maven.plugins maven-project-info-reports-plugin - 3.6.1 + 3.6.2 From 2be70c74f673c796d7b366b56644b6d00038bc07 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Thu, 25 Jul 2024 13:06:01 +0200 Subject: [PATCH 10/20] deps: update dependency org.springframework.boot:spring-boot-starter-parent to v3.3.2 (#1686) --- samples/spring-data-mybatis/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/samples/spring-data-mybatis/pom.xml b/samples/spring-data-mybatis/pom.xml index b9fe2a929..a5ad7633d 100644 --- a/samples/spring-data-mybatis/pom.xml +++ b/samples/spring-data-mybatis/pom.xml @@ -13,7 +13,7 @@ org.springframework.boot spring-boot-starter-parent - 3.3.1 + 3.3.2 From 6a57b49a34f2b44f42f6c07eaf5da063a1d648d0 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Thu, 25 Jul 2024 13:06:14 +0200 Subject: [PATCH 11/20] deps: update dependency org.springframework.boot:spring-boot-starter-data-jdbc to v3.3.2 (#1685) --- samples/spring-data-jdbc/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/samples/spring-data-jdbc/pom.xml b/samples/spring-data-jdbc/pom.xml index 0d9e94c96..f2d20d8ac 100644 --- a/samples/spring-data-jdbc/pom.xml +++ b/samples/spring-data-jdbc/pom.xml @@ -55,7 +55,7 @@ org.springframework.boot spring-boot-starter-data-jdbc - 3.3.1 + 3.3.2 From 34cb1278a37e3227314090737924e4c4c8c331df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Knut=20Olav=20L=C3=B8ite?= Date: Thu, 25 Jul 2024 17:35:16 +0200 Subject: [PATCH 12/20] test: add test to verify client-lib header is included (#1689) --- .../cloud/spanner/jdbc/JdbcDriverTest.java | 32 ++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcDriverTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcDriverTest.java index 36c97fa5e..13efeb817 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcDriverTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcDriverTest.java @@ -18,8 +18,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; +import com.google.cloud.ServiceOptions; import com.google.cloud.spanner.MockSpannerServiceImpl; import com.google.cloud.spanner.connection.ConnectionOptions; import com.google.cloud.spanner.connection.ConnectionOptions.ConnectionProperty; @@ -27,7 +30,14 @@ import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; import com.google.rpc.Code; +import io.grpc.Context; +import io.grpc.Contexts; +import io.grpc.Metadata; import io.grpc.Server; +import io.grpc.ServerCall; +import io.grpc.ServerCall.Listener; +import io.grpc.ServerCallHandler; +import io.grpc.ServerInterceptor; import io.grpc.netty.shaded.io.grpc.netty.NettyServerBuilder; import java.io.IOException; import java.net.InetSocketAddress; @@ -64,7 +74,27 @@ public class JdbcDriverTest { public static void startStaticServer() throws IOException { MockSpannerServiceImpl mockSpanner = new MockSpannerServiceImpl(); InetSocketAddress address = new InetSocketAddress("localhost", 0); - server = NettyServerBuilder.forAddress(address).addService(mockSpanner).build().start(); + server = + NettyServerBuilder.forAddress(address) + .addService(mockSpanner) + .intercept( + new ServerInterceptor() { + @Override + public Listener interceptCall( + ServerCall call, + Metadata headers, + ServerCallHandler next) { + String clientLibToken = + headers.get( + Metadata.Key.of("x-goog-api-client", Metadata.ASCII_STRING_MARSHALLER)); + assertNotNull(clientLibToken); + assertTrue( + clientLibToken.contains(ServiceOptions.getGoogApiClientLibName() + "/")); + return Contexts.interceptCall(Context.current(), call, headers, next); + } + }) + .build() + .start(); } @AfterClass From 3933cf2c4099e0d06c1dc4e4583c11ba5e4eae19 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 6 Aug 2024 17:45:01 +0200 Subject: [PATCH 13/20] deps: update dependency org.hamcrest:hamcrest to v3 (#1697) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * deps: update dependency org.hamcrest:hamcrest to v3 * deps: remove separate hamcrest dependency management * chore: remove all usage of hamcrest --------- Co-authored-by: Knut Olav Løite --- pom.xml | 13 - .../cloud/spanner/jdbc/JdbcBlobTest.java | 177 ++--- .../cloud/spanner/jdbc/JdbcClobTest.java | 202 +++-- .../spanner/jdbc/JdbcConnectionTest.java | 10 +- .../jdbc/JdbcDatabaseMetaDataTest.java | 403 +++++----- .../spanner/jdbc/JdbcExceptionMatcher.java | 64 -- .../cloud/spanner/jdbc/JdbcGrpcErrorTest.java | 221 +++--- .../cloud/spanner/jdbc/JdbcResultSetTest.java | 96 +-- .../cloud/spanner/jdbc/JdbcStatementTest.java | 140 ++-- .../jdbc/SpannerJdbcExceptionMatcher.java | 70 -- .../spanner/jdbc/it/ITAbstractJdbcTest.java | 3 - .../jdbc/it/ITJdbcDatabaseMetaDataTest.java | 739 +++++++++--------- .../it/ITJdbcReadWriteAutocommitTest.java | 9 +- .../spanner/jdbc/it/ITJdbcScriptTest.java | 19 +- 14 files changed, 965 insertions(+), 1201 deletions(-) delete mode 100644 src/test/java/com/google/cloud/spanner/jdbc/JdbcExceptionMatcher.java delete mode 100644 src/test/java/com/google/cloud/spanner/jdbc/SpannerJdbcExceptionMatcher.java diff --git a/pom.xml b/pom.xml index 9cece1c6b..59adb9d33 100644 --- a/pom.xml +++ b/pom.xml @@ -53,7 +53,6 @@ 3.0.2 1.4.4 4.11.0 - 2.2 0.31.1 @@ -182,23 +181,11 @@ - - org.hamcrest - hamcrest - ${hamcrest.version} - test - org.mockito mockito-core ${mockito.version} test - - - org.hamcrest - hamcrest-core - - junit diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcBlobTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcBlobTest.java index 46b85fe2d..e7be0ecee 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcBlobTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcBlobTest.java @@ -16,9 +16,10 @@ package com.google.cloud.spanner.jdbc; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import com.google.rpc.Code; import java.io.IOException; @@ -74,35 +75,31 @@ public String toString() { @Test public void testLength() throws SQLException { JdbcBlob blob = new JdbcBlob(); - assertThat(blob.length(), is(equalTo(0L))); + assertEquals(0L, blob.length()); blob.setBytes(1L, new byte[] {1, 2, 3}); - assertThat(blob.length(), is(equalTo(3L))); + assertEquals(3L, blob.length()); blob.free(); - assertThat(blob.length(), is(equalTo(0L))); + assertEquals(0L, blob.length()); } @Test public void testGetBytes() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(1L, new byte[] {1, 2, 3, 4, 5}); - assertThat(blob.getBytes(1L, 5), is(equalTo(new byte[] {1, 2, 3, 4, 5}))); - assertThat(blob.getBytes(2L, 5), is(equalTo(new byte[] {2, 3, 4, 5}))); - assertThat(blob.getBytes(2L, 3), is(equalTo(new byte[] {2, 3, 4}))); - assertThat(blob.getBytes(1L, 0), is(equalTo(new byte[] {}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5}, blob.getBytes(1L, 5)); + assertArrayEquals(new byte[] {2, 3, 4, 5}, blob.getBytes(2L, 5)); + assertArrayEquals(new byte[] {2, 3, 4}, blob.getBytes(2L, 3)); + assertArrayEquals(new byte[] {}, blob.getBytes(1L, 0)); // test invalid parameters PosLength[] params = new PosLength[] {PosLength.of(0L, 4), PosLength.of(-1L, 4), PosLength.of(1L, -1)}; for (PosLength param : params) { - boolean exception = false; - try { - blob.getBytes(param.pos, param.len); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows(SQLException.class, () -> blob.getBytes(param.pos, param.len)); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -119,31 +116,31 @@ public void testGetBinaryStream() throws SQLException, IOException { index++; } } - assertThat(buf, is(equalTo(new byte[] {1, 2, 3, 4, 5}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5}, buf); buf = new byte[10]; try (InputStream is = blob.getBinaryStream()) { - assertThat(is.read(buf), is(equalTo(5))); - assertThat(is.read(), is(equalTo(-1))); + assertEquals(5, is.read(buf)); + assertEquals(-1, is.read()); } - assertThat(buf, is(equalTo(new byte[] {1, 2, 3, 4, 5, 0, 0, 0, 0, 0}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 0, 0, 0, 0, 0}, buf); } @Test public void testPosition() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(1L, new byte[] {1, 2, 3, 4, 5}); - assertThat(blob.position(new byte[] {1}, 1L), is(equalTo(1L))); - assertThat(blob.position(new byte[] {1, 2}, 1L), is(equalTo(1L))); - assertThat(blob.position(new byte[] {2}, 1L), is(equalTo(2L))); + assertEquals(1L, blob.position(new byte[] {1}, 1L)); + assertEquals(1L, blob.position(new byte[] {1, 2}, 1L)); + assertEquals(2L, blob.position(new byte[] {2}, 1L)); // note that the spec says that the method should return the position within the BLOB where the // pattern can be found, so it's not relative to the starting position. - assertThat(blob.position(new byte[] {2}, 2L), is(equalTo(2L))); - assertThat(blob.position(new byte[] {1, 2, 3, 4, 5}, 1L), is(equalTo(1L))); - assertThat(blob.position(new byte[] {1, 2, 3, 4, 5, 6}, 1L), is(equalTo(-1L))); - assertThat(blob.position(new byte[] {1, 2, 3, 4, 5}, 2L), is(equalTo(-1L))); - assertThat(blob.position(new byte[] {2}, 3L), is(equalTo(-1L))); - assertThat(blob.position(new byte[] {1}, 6L), is(equalTo(-1L))); + assertEquals(2L, blob.position(new byte[] {2}, 2L)); + assertEquals(1L, blob.position(new byte[] {1, 2, 3, 4, 5}, 1L)); + assertEquals(-1L, blob.position(new byte[] {1, 2, 3, 4, 5, 6}, 1L)); + assertEquals(-1L, blob.position(new byte[] {1, 2, 3, 4, 5}, 2L)); + assertEquals(-1L, blob.position(new byte[] {2}, 3L)); + assertEquals(-1L, blob.position(new byte[] {1}, 6L)); // test invalid parameters PosBytes[] params = @@ -151,15 +148,11 @@ public void testPosition() throws SQLException { PosBytes.of(0L, new byte[] {}), PosBytes.of(-1L, new byte[] {}), PosBytes.of(1L, null) }; for (PosBytes param : params) { - boolean exception = false; - try { - blob.position(param.bytes, param.pos); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows(SQLException.class, () -> blob.position(param.bytes, param.pos)); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -168,17 +161,17 @@ public void testPositionBlob() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(1L, new byte[] {1, 2, 3, 4, 5}); - assertThat(blob.position(createBlob((byte) 1), 1L), is(equalTo(1L))); - assertThat(blob.position(createBlob((byte) 1, (byte) 2), 1L), is(equalTo(1L))); - assertThat(blob.position(createBlob((byte) 2), 1L), is(equalTo(2L))); + assertEquals(1L, blob.position(createBlob((byte) 1), 1L)); + assertEquals(1L, blob.position(createBlob((byte) 1, (byte) 2), 1L)); + assertEquals(2L, blob.position(createBlob((byte) 2), 1L)); // note that the spec says that the method should return the position within the BLOB where the // pattern can be found, so it's not relative to the starting position. - assertThat(blob.position(createBlob((byte) 2), 2L), is(equalTo(2L))); - assertThat(blob.position(createBlob(new byte[] {1, 2, 3, 4, 5}), 1L), is(equalTo(1L))); - assertThat(blob.position(createBlob(new byte[] {1, 2, 3, 4, 5, 6}), 1L), is(equalTo(-1L))); - assertThat(blob.position(createBlob(new byte[] {1, 2, 3, 4, 5}), 2L), is(equalTo(-1L))); - assertThat(blob.position(createBlob(new byte[] {2}), 3L), is(equalTo(-1L))); - assertThat(blob.position(createBlob(new byte[] {1}), 6L), is(equalTo(-1L))); + assertEquals(2L, blob.position(createBlob((byte) 2), 2L)); + assertEquals(1L, blob.position(createBlob(new byte[] {1, 2, 3, 4, 5}), 1L)); + assertEquals(-1L, blob.position(createBlob(new byte[] {1, 2, 3, 4, 5, 6}), 1L)); + assertEquals(-1L, blob.position(createBlob(new byte[] {1, 2, 3, 4, 5}), 2L)); + assertEquals(-1L, blob.position(createBlob(new byte[] {2}), 3L)); + assertEquals(-1L, blob.position(createBlob(new byte[] {1}), 6L)); // test invalid parameters PosBytes[] params = @@ -186,15 +179,11 @@ public void testPositionBlob() throws SQLException { PosBytes.of(0L, new byte[] {}), PosBytes.of(-1L, new byte[] {}), PosBytes.of(1L, null) }; for (PosBytes param : params) { - boolean exception = false; - try { - blob.position(createBlob(param.bytes), param.pos); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows(SQLException.class, () -> blob.position(createBlob(param.bytes), param.pos)); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -211,35 +200,35 @@ private JdbcBlob createBlob(byte... bytes) throws SQLException { public void testSetBytes() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(1L, new byte[] {1, 2, 3}); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {1, 2, 3}))); + assertArrayEquals(new byte[] {1, 2, 3}, blob.getBytes(1L, 10)); blob.setBytes(2L, new byte[] {1}); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {1, 1, 3}))); + assertArrayEquals(new byte[] {1, 1, 3}, blob.getBytes(1L, 10)); blob.setBytes(4L, new byte[] {4}); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {1, 1, 3, 4}))); + assertArrayEquals(new byte[] {1, 1, 3, 4}, blob.getBytes(1L, 10)); blob.setBytes(8L, new byte[] {8}); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {1, 1, 3, 4, 0, 0, 0, 8}))); + assertArrayEquals(new byte[] {1, 1, 3, 4, 0, 0, 0, 8}, blob.getBytes(1L, 10)); } @Test public void testSetBytesOffsetLength() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(4L, new byte[] {1, 2, 3}, 0, 3); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {0, 0, 0, 1, 2, 3}))); + assertArrayEquals(new byte[] {0, 0, 0, 1, 2, 3}, blob.getBytes(1L, 10)); blob.free(); blob.setBytes(4L, new byte[] {1, 2, 3}, 1, 3); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {0, 0, 0, 2, 3}))); + assertArrayEquals(new byte[] {0, 0, 0, 2, 3}, blob.getBytes(1L, 10)); blob.free(); blob.setBytes(4L, new byte[] {1, 2, 3}, 3, 3); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {0, 0, 0}))); + assertArrayEquals(new byte[] {0, 0, 0}, blob.getBytes(1L, 10)); blob.free(); blob.setBytes(4L, new byte[] {1, 2, 3}, 4, 3); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {0, 0, 0}))); + assertArrayEquals(new byte[] {0, 0, 0}, blob.getBytes(1L, 10)); blob.setBytes(2L, new byte[] {1, 2, 3}, 0, 10); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {0, 1, 2, 3}))); + assertArrayEquals(new byte[] {0, 1, 2, 3}, blob.getBytes(1L, 10)); blob.setBytes(3L, new byte[] {1, 2, 3}, 2, 10); - assertThat(blob.getBytes(1L, 10), is(equalTo(new byte[] {0, 1, 3, 3}))); + assertArrayEquals(new byte[] {0, 1, 3, 3}, blob.getBytes(1L, 10)); blob.setBytes(10L, new byte[] {1, 2, 3}, 2, 10); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {0, 1, 3, 3, 0, 0, 0, 0, 0, 3}))); + assertArrayEquals(new byte[] {0, 1, 3, 3, 0, 0, 0, 0, 0, 3}, blob.getBytes(1L, 20)); } @Test @@ -249,51 +238,49 @@ public void testSetBinaryStream() throws SQLException, IOException { try (OutputStream os = blob.setBinaryStream(1L)) { os.write(6); // no flush yet, so it should be unchanged - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 5}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5}, blob.getBytes(1L, 20)); os.flush(); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {6, 2, 3, 4, 5}))); + assertArrayEquals(new byte[] {6, 2, 3, 4, 5}, blob.getBytes(1L, 20)); os.write(7); } // closing the stream should also flush the changes - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {6, 7, 3, 4, 5}))); + assertArrayEquals(new byte[] {6, 7, 3, 4, 5}, blob.getBytes(1L, 20)); // test writing beyond the end of the stream try (OutputStream os = blob.setBinaryStream(1L)) { os.write(new byte[] {1, 2, 3, 4, 5, 6, 7}); // no flush yet, so it should be unchanged - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {6, 7, 3, 4, 5}))); + assertArrayEquals(new byte[] {6, 7, 3, 4, 5}, blob.getBytes(1L, 20)); os.flush(); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 5, 6, 7}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 7}, blob.getBytes(1L, 20)); } - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 5, 6, 7}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 7}, blob.getBytes(1L, 20)); // test writing from a position that is larger than 1 try (OutputStream os = blob.setBinaryStream(5L)) { os.write(new byte[] {1, 2, 3}); // no flush yet, so it should be unchanged - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 5, 6, 7}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 7}, blob.getBytes(1L, 20)); os.flush(); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 1, 2, 3}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 1, 2, 3}, blob.getBytes(1L, 20)); } // test writing from a position that is larger than the current length try (OutputStream os = blob.setBinaryStream(10L)) { os.write(new byte[] {1, 2, 3}); // no flush yet, so it should be unchanged - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 1, 2, 3}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 1, 2, 3}, blob.getBytes(1L, 20)); os.flush(); - assertThat( - blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 1, 2, 3, 0, 0, 1, 2, 3}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 1, 2, 3, 0, 0, 1, 2, 3}, blob.getBytes(1L, 20)); } // test writing a large number of bytes try (OutputStream os = blob.setBinaryStream(1L)) { os.write(new byte[2000]); // no flush yet, so it should be unchanged - assertThat( - blob.getBytes(1L, 3000), is(equalTo(new byte[] {1, 2, 3, 4, 1, 2, 3, 0, 0, 1, 2, 3}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 1, 2, 3, 0, 0, 1, 2, 3}, blob.getBytes(1L, 3000)); os.flush(); - assertThat(blob.getBytes(1L, 3000), is(equalTo(new byte[2000]))); + assertArrayEquals(new byte[2000], blob.getBytes(1L, 3000)); } } @@ -301,20 +288,20 @@ public void testSetBinaryStream() throws SQLException, IOException { public void testTruncate() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(1L, new byte[] {1, 2, 3, 4, 5}); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 5}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5}, blob.getBytes(1L, 20)); blob.truncate(3); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3}))); + assertArrayEquals(new byte[] {1, 2, 3}, blob.getBytes(1L, 20)); blob.truncate(0); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {}))); + assertArrayEquals(new byte[] {}, blob.getBytes(1L, 20)); } @Test public void testFree() throws SQLException { JdbcBlob blob = new JdbcBlob(); blob.setBytes(1L, new byte[] {1, 2, 3, 4, 5}); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {1, 2, 3, 4, 5}))); + assertArrayEquals(new byte[] {1, 2, 3, 4, 5}, blob.getBytes(1L, 20)); blob.free(); - assertThat(blob.getBytes(1L, 20), is(equalTo(new byte[] {}))); + assertArrayEquals(new byte[] {}, blob.getBytes(1L, 20)); } @Test @@ -331,19 +318,19 @@ public void testGetBinaryStreamPosLength() throws SQLException, IOException { index++; } } - assertThat(buf, is(equalTo(new byte[] {1, 2, 3, 0, 0}))); + assertArrayEquals(new byte[] {1, 2, 3, 0, 0}, buf); buf = new byte[10]; try (InputStream is = blob.getBinaryStream(4L, 10)) { - assertThat(is.read(buf), is(equalTo(2))); - assertThat(is.read(), is(equalTo(-1))); + assertEquals(2, is.read(buf)); + assertEquals(-1, is.read()); } - assertThat(buf, is(equalTo(new byte[] {4, 5, 0, 0, 0, 0, 0, 0, 0, 0}))); + assertArrayEquals(new byte[] {4, 5, 0, 0, 0, 0, 0, 0, 0, 0}, buf); buf = new byte[10]; try (InputStream is = blob.getBinaryStream(6L, 10)) { - assertThat(is.read(buf), is(equalTo(-1))); + assertEquals(-1L, is.read(buf)); } - assertThat(buf, is(equalTo(new byte[10]))); + assertArrayEquals(new byte[10], buf); } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcClobTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcClobTest.java index b19522918..573200ddf 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcClobTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcClobTest.java @@ -16,10 +16,10 @@ package com.google.cloud.spanner.jdbc; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import com.google.rpc.Code; import java.io.IOException; @@ -75,36 +75,32 @@ public String toString() { public void testLength() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "test"); - assertThat(clob.length(), is(equalTo(4L))); + assertEquals(4L, clob.length()); clob.setString(1L, "test-test"); - assertThat(clob.length(), is(equalTo(9L))); + assertEquals(9L, clob.length()); } @Test public void testGetSubstring() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "test"); - assertThat(clob.getSubString(1, 4), is(equalTo("test"))); - assertThat(clob.getSubString(1, 2), is(equalTo("te"))); - assertThat(clob.getSubString(3, 2), is(equalTo("st"))); - assertThat(clob.getSubString(1, 5), is(equalTo("test"))); - assertThat(clob.getSubString(4, 5), is(equalTo("t"))); - assertThat(clob.getSubString(5, 5), is(equalTo(""))); - assertThat(clob.getSubString(6, 5), is(equalTo(""))); + assertEquals("test", clob.getSubString(1, 4)); + assertEquals("te", clob.getSubString(1, 2)); + assertEquals("st", clob.getSubString(3, 2)); + assertEquals("test", clob.getSubString(1, 5)); + assertEquals("t", clob.getSubString(4, 5)); + assertEquals("", clob.getSubString(5, 5)); + assertEquals("", clob.getSubString(6, 5)); // test invalid parameters PosLength[] params = new PosLength[] {PosLength.of(0L, 4), PosLength.of(-1L, 4), PosLength.of(1L, -1)}; for (PosLength param : params) { - boolean exception = false; - try { - clob.getSubString(param.pos, param.len); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows(SQLException.class, () -> clob.getSubString(param.pos, param.len)); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -116,12 +112,12 @@ public void testGetCharacterStream() throws SQLException, IOException { try (Reader reader = clob.getCharacterStream()) { assertEquals(4, reader.read(cbuf, 0, 4)); } - assertThat(cbuf, is(equalTo(new char[] {'t', 'e', 's', 't'}))); + assertArrayEquals(new char[] {'t', 'e', 's', 't'}, cbuf); try (Reader reader = clob.getCharacterStream()) { assertEquals(2, reader.read(cbuf, 0, 2)); assertEquals(2, reader.read(cbuf, 2, 2)); } - assertThat(cbuf, is(equalTo(new char[] {'t', 'e', 's', 't'}))); + assertArrayEquals(new char[] {'t', 'e', 's', 't'}, cbuf); try (Reader reader = clob.getCharacterStream()) { assertEquals(2, reader.read(cbuf, 0, 2)); // changing the value of the clob will not change a character stream that has already been @@ -129,36 +125,32 @@ public void testGetCharacterStream() throws SQLException, IOException { clob.setString(1L, "foobar"); assertEquals(2, reader.read(cbuf, 2, 2)); } - assertThat(cbuf, is(equalTo(new char[] {'t', 'e', 's', 't'}))); + assertArrayEquals(new char[] {'t', 'e', 's', 't'}, cbuf); } @Test public void testPositionString() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "test"); - assertThat(clob.position("st", 1L), is(equalTo(3L))); + assertEquals(3L, clob.position("st", 1L)); clob.setString(1L, "foobarfoobar"); - assertThat(clob.position("bar", 1L), is(equalTo(4L))); - assertThat(clob.position("bar", 2L), is(equalTo(4L))); - assertThat(clob.position("bar", 5L), is(equalTo(10L))); - assertThat(clob.position("bar", 8L), is(equalTo(10L))); - assertThat(clob.position("bar", 10L), is(equalTo(10L))); - assertThat(clob.position("bar", 11L), is(equalTo(-1L))); - assertThat(clob.position("bar", 100L), is(equalTo(-1L))); - assertThat(clob.position("not_there", 1L), is(equalTo(-1L))); + assertEquals(4L, clob.position("bar", 1L)); + assertEquals(4L, clob.position("bar", 2L)); + assertEquals(10L, clob.position("bar", 5L)); + assertEquals(10L, clob.position("bar", 8L)); + assertEquals(10L, clob.position("bar", 10L)); + assertEquals(-1L, clob.position("bar", 11L)); + assertEquals(-1L, clob.position("bar", 100L)); + assertEquals(-1L, clob.position("not_there", 1L)); // test invalid parameters PosString[] params = new PosString[] {PosString.of(0L, "bar"), PosString.of(-1L, "bar"), PosString.of(1L, null)}; for (PosString param : params) { - boolean exception = false; - try { - clob.position(param.str, param.pos); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows(SQLException.class, () -> clob.position(param.str, param.pos)); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -168,32 +160,32 @@ public void testPositionClob() throws SQLException { clob.setString(1L, "test"); JdbcClob search = new JdbcClob(); search.setString(1L, "st"); - assertThat(clob.position(search, 1L), is(equalTo(3L))); + assertEquals(3L, clob.position(search, 1L)); clob.setString(1L, "foobarfoobar"); search.setString(1L, "bar"); - assertThat(clob.position(search, 1L), is(equalTo(4L))); - assertThat(clob.position(search, 2L), is(equalTo(4L))); - assertThat(clob.position(search, 5L), is(equalTo(10L))); - assertThat(clob.position(search, 8L), is(equalTo(10L))); - assertThat(clob.position(search, 10L), is(equalTo(10L))); - assertThat(clob.position(search, 11L), is(equalTo(-1L))); - assertThat(clob.position(search, 100L), is(equalTo(-1L))); + assertEquals(4L, clob.position(search, 1L)); + assertEquals(4L, clob.position(search, 2L)); + assertEquals(10L, clob.position(search, 5L)); + assertEquals(10L, clob.position(search, 8L)); + assertEquals(10L, clob.position(search, 10L)); + assertEquals(-1L, clob.position(search, 11L)); + assertEquals(-1L, clob.position(search, 100L)); search.setString(1L, "not_there"); - assertThat(clob.position(search, 1L), is(equalTo(-1L))); + assertEquals(-1L, clob.position(search, 1L)); // test invalid parameters PosString[] params = new PosString[] {PosString.of(0L, "bar"), PosString.of(-1L, "bar"), PosString.of(1L, null)}; for (PosString param : params) { - boolean exception = false; - try { - search.setString(1L, param.str); - clob.position(search, param.pos); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows( + SQLException.class, + () -> { + search.setString(1L, param.str); + clob.position(search, param.pos); + }); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -201,30 +193,26 @@ public void testPositionClob() throws SQLException { public void testSetString() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "test"); - assertThat(clob.getSubString(1L, 4), is(equalTo("test"))); + assertEquals("test", clob.getSubString(1L, 4)); clob.setString(1L, "bar"); - assertThat(clob.getSubString(1L, 4), is(equalTo("bart"))); + assertEquals("bart", clob.getSubString(1L, 4)); clob.setString(1L, "foobar"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); clob.setString(2L, "foobar"); - assertThat(clob.getSubString(1L, 7), is(equalTo("ffoobar"))); + assertEquals("ffoobar", clob.getSubString(1L, 7)); clob.setString(8L, "test"); - assertThat(clob.getSubString(1L, 11), is(equalTo("ffoobartest"))); + assertEquals("ffoobartest", clob.getSubString(1L, 11)); clob.setString(15, "end"); - assertThat(clob.getSubString(1L, 17), is(equalTo("ffoobartest end"))); + assertEquals("ffoobartest end", clob.getSubString(1L, 17)); // test invalid parameters PosString[] params = new PosString[] {PosString.of(0L, "bar"), PosString.of(-1L, "bar"), PosString.of(1L, null)}; for (PosString param : params) { - boolean exception = false; - try { - clob.setString(param.pos, param.str); - } catch (SQLException e) { - exception = - (e instanceof JdbcSqlException - && ((JdbcSqlException) e).getCode() == Code.INVALID_ARGUMENT); - } - assertThat(param.toString(), exception, is(true)); + SQLException sqlException = + assertThrows(SQLException.class, () -> clob.setString(param.pos, param.str)); + assertTrue(sqlException instanceof JdbcSqlException); + JdbcSqlException jdbcSqlException = (JdbcSqlException) sqlException; + assertEquals(Code.INVALID_ARGUMENT, jdbcSqlException.getCode()); } } @@ -232,99 +220,99 @@ public void testSetString() throws SQLException { public void testSetStringOffsetLen() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "test", 2, 3); - assertThat(clob.getSubString(1L, 4), is(equalTo("est"))); + assertEquals("est", clob.getSubString(1L, 4)); clob.setString(1L, "bar", 1, 1); - assertThat(clob.getSubString(1L, 4), is(equalTo("bst"))); + assertEquals("bst", clob.getSubString(1L, 4)); clob.setString(1L, "foobar", 1, 6); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); clob.setString(2L, "foobar", 2, 5); - assertThat(clob.getSubString(1L, 7), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 7)); clob.setString(8L, "test", 4, 1); - assertThat(clob.getSubString(1L, 8), is(equalTo("foobar t"))); + assertEquals("foobar t", clob.getSubString(1L, 8)); clob.setString(15, "end", 1, 3); - assertThat(clob.getSubString(1L, 17), is(equalTo("foobar t end"))); + assertEquals("foobar t end", clob.getSubString(1L, 17)); } @Test public void testSetCharacterStream() throws SQLException, IOException { JdbcClob clob = new JdbcClob(); clob.setString(1, "foobar"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); try (Writer writer = clob.setCharacterStream(1L)) { writer.write("t"); // not yet flushed, there should be no change - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); writer.flush(); // after a flush the change should be visible - assertThat(clob.getSubString(1L, 6), is(equalTo("toobar"))); + assertEquals("toobar", clob.getSubString(1L, 6)); writer.write("est"); } - // close should also autoflush - assertThat(clob.getSubString(1L, 6), is(equalTo("testar"))); + // close should also auto-flush + assertEquals("testar", clob.getSubString(1L, 6)); // start all over clob.free(); clob.setString(1, "foobar"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); try (Writer writer = clob.setCharacterStream(5L)) { writer.write("t"); // not yet flushed, there should be no change - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); writer.flush(); // after a flush the change should be visible - assertThat(clob.getSubString(1L, 6), is(equalTo("foobtr"))); + assertEquals("foobtr", clob.getSubString(1L, 6)); writer.write("est"); } - // close should also autoflush - assertThat(clob.getSubString(1L, 8), is(equalTo("foobtest"))); + // close should also auto-flush + assertEquals("foobtest", clob.getSubString(1L, 8)); // do a test with multiple flushes clob.free(); clob.setString(1, "foobar"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); try (Writer writer = clob.setCharacterStream(1L)) { writer.write("t"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); writer.flush(); - assertThat(clob.getSubString(1L, 6), is(equalTo("toobar"))); + assertEquals("toobar", clob.getSubString(1L, 6)); writer.write("est"); - assertThat(clob.getSubString(1L, 6), is(equalTo("toobar"))); + assertEquals("toobar", clob.getSubString(1L, 6)); writer.flush(); - assertThat(clob.getSubString(1L, 6), is(equalTo("testar"))); + assertEquals("testar", clob.getSubString(1L, 6)); } - assertThat(clob.getSubString(1L, 8), is(equalTo("testar"))); + assertEquals("testar", clob.getSubString(1L, 8)); // writer after end clob.free(); clob.setString(1, "foobar"); - assertThat(clob.getSubString(1L, 10), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 10)); try (Writer writer = clob.setCharacterStream(10L)) { writer.write("t"); - assertThat(clob.getSubString(1L, 20), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 20)); writer.flush(); - assertThat(clob.getSubString(1L, 20), is(equalTo("foobar t"))); + assertEquals("foobar t", clob.getSubString(1L, 20)); writer.write("est"); } - assertThat(clob.getSubString(1L, 20), is(equalTo("foobar test"))); + assertEquals("foobar test", clob.getSubString(1L, 20)); } @Test public void testTruncate() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "foobar"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); clob.truncate(3L); - assertThat(clob.getSubString(1L, 6), is(equalTo("foo"))); + assertEquals("foo", clob.getSubString(1L, 6)); clob.truncate(0L); - assertThat(clob.getSubString(1L, 6), is(equalTo(""))); + assertEquals("", clob.getSubString(1L, 6)); } @Test public void testFree() throws SQLException { JdbcClob clob = new JdbcClob(); clob.setString(1L, "foobar"); - assertThat(clob.getSubString(1L, 6), is(equalTo("foobar"))); + assertEquals("foobar", clob.getSubString(1L, 6)); clob.free(); - assertThat(clob.getSubString(1L, 6), is(equalTo(""))); + assertEquals("", clob.getSubString(1L, 6)); } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionTest.java index cda51a771..5a9618e9a 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionTest.java @@ -24,7 +24,6 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -118,7 +117,7 @@ public void testAutoCommit() throws SQLException { } @Test - public void testReadOnly() { + public void testReadOnly() throws SQLException { ConnectionOptions options = mockOptions(); when(options.isAutocommit()).thenReturn(true); when(options.isReadOnly()).thenReturn(true); @@ -129,10 +128,9 @@ public void testReadOnly() { // start a transaction connection.createStatement().execute("begin transaction"); // setting readonly should no longer be allowed - connection.setReadOnly(true); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(JdbcExceptionMatcher.matchCode(Code.FAILED_PRECONDITION).matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> connection.setReadOnly(true)); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java index 1dc95655f..3e94a4ceb 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java @@ -16,12 +16,9 @@ package com.google.cloud.spanner.jdbc; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -65,100 +62,97 @@ public static Object[] data() { public void testTrivialMethods() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); - assertThat(meta.allProceduresAreCallable(), is(true)); - assertThat(meta.allTablesAreSelectable(), is(true)); - assertThat(meta.autoCommitFailureClosesAllResultSets(), is(false)); - assertThat(meta.dataDefinitionCausesTransactionCommit(), is(false)); - assertThat(meta.dataDefinitionIgnoredInTransactions(), is(false)); + assertTrue(meta.allProceduresAreCallable()); + assertTrue(meta.allTablesAreSelectable()); + assertFalse(meta.autoCommitFailureClosesAllResultSets()); + assertFalse(meta.dataDefinitionCausesTransactionCommit()); + assertFalse(meta.dataDefinitionIgnoredInTransactions()); for (int type : new int[] { ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.TYPE_SCROLL_SENSITIVE }) { - assertThat(meta.deletesAreDetected(type), is(false)); - assertThat(meta.insertsAreDetected(type), is(false)); - assertThat(meta.updatesAreDetected(type), is(false)); - assertThat(meta.ownDeletesAreVisible(type), is(false)); - assertThat(meta.ownInsertsAreVisible(type), is(false)); - assertThat(meta.ownUpdatesAreVisible(type), is(false)); - assertThat(meta.othersDeletesAreVisible(type), is(false)); - assertThat(meta.othersInsertsAreVisible(type), is(false)); - assertThat(meta.othersUpdatesAreVisible(type), is(false)); + assertFalse(meta.deletesAreDetected(type)); + assertFalse(meta.insertsAreDetected(type)); + assertFalse(meta.updatesAreDetected(type)); + assertFalse(meta.ownDeletesAreVisible(type)); + assertFalse(meta.ownInsertsAreVisible(type)); + assertFalse(meta.ownUpdatesAreVisible(type)); + assertFalse(meta.othersDeletesAreVisible(type)); + assertFalse(meta.othersInsertsAreVisible(type)); + assertFalse(meta.othersUpdatesAreVisible(type)); } - assertThat(meta.doesMaxRowSizeIncludeBlobs(), is(true)); - assertThat(meta.generatedKeyAlwaysReturned(), is(false)); - assertThat(meta.getCatalogSeparator(), is(equalTo("."))); - assertThat(meta.getCatalogTerm(), is(equalTo("CATALOG"))); - assertThat(meta.getDatabaseMajorVersion(), is(equalTo(DATABASE_MAJOR_VERSION))); - assertThat(meta.getDatabaseMinorVersion(), is(equalTo(DATABASE_MINOR_VERSION))); - assertThat(meta.getDatabaseProductName(), is(equalTo(DATABASE_PRODUCT_NAME))); - assertThat( - meta.getDatabaseProductVersion(), - is(equalTo(DATABASE_MAJOR_VERSION + "." + DATABASE_MINOR_VERSION))); - assertThat( - meta.getDefaultTransactionIsolation(), is(equalTo(Connection.TRANSACTION_SERIALIZABLE))); - assertThat(meta.getDriverName(), is(equalTo("com.google.cloud.spanner.jdbc.JdbcDriver"))); - assertThat(meta.getExtraNameCharacters(), is(equalTo(""))); - assertThat(meta.getIdentifierQuoteString(), is(equalTo("`"))); - assertThat(meta.getJDBCMajorVersion(), is(equalTo(4))); - assertThat(meta.getJDBCMinorVersion(), is(equalTo(1))); // Java 7 is JDBC 4.1 - assertThat(meta.getMaxBinaryLiteralLength(), is(equalTo(0))); - assertThat(meta.getMaxCatalogNameLength(), is(equalTo(0))); - assertThat(meta.getMaxCharLiteralLength(), is(equalTo(0))); - assertThat(meta.getMaxColumnNameLength(), is(equalTo(128))); - assertThat(meta.getMaxColumnsInGroupBy(), is(equalTo(1000))); - assertThat(meta.getMaxColumnsInIndex(), is(equalTo(16))); - assertThat(meta.getMaxColumnsInOrderBy(), is(equalTo(0))); - assertThat(meta.getMaxColumnsInSelect(), is(equalTo(0))); - assertThat(meta.getMaxColumnsInTable(), is(equalTo(1024))); - assertThat(meta.getMaxConnections(), is(equalTo(0))); // there is a max number of sessions, but - // that is not the same as connections - assertThat(meta.getMaxCursorNameLength(), is(equalTo(0))); - assertThat(meta.getMaxIndexLength(), is(equalTo(8000))); - assertThat(meta.getMaxProcedureNameLength(), is(equalTo(0))); - assertThat(meta.getMaxRowSize(), is(equalTo(0))); - assertThat(meta.getMaxSchemaNameLength(), is(equalTo(0))); - assertThat(meta.getMaxStatementLength(), is(equalTo(1000000))); - assertThat(meta.getMaxStatements(), is(equalTo(0))); - assertThat(meta.getMaxTableNameLength(), is(equalTo(128))); - assertThat(meta.getMaxTablesInSelect(), is(equalTo(0))); - assertThat(meta.getMaxUserNameLength(), is(equalTo(0))); - assertThat(meta.getProcedureTerm(), is(equalTo("PROCEDURE"))); - assertThat(meta.getResultSetHoldability(), is(equalTo(ResultSet.CLOSE_CURSORS_AT_COMMIT))); - assertThat(meta.getRowIdLifetime(), is(equalTo(RowIdLifetime.ROWID_UNSUPPORTED))); - assertThat(meta.getSchemaTerm(), is(equalTo("SCHEMA"))); - assertThat(meta.getSearchStringEscape(), is(equalTo("\\"))); - assertThat(meta.getSQLStateType(), is(equalTo(DatabaseMetaData.sqlStateSQL))); - assertThat(meta.locatorsUpdateCopy(), is(true)); - assertThat(meta.nullsAreSortedHigh(), is(false)); - assertThat(meta.nullsAreSortedLow(), is(true)); - assertThat(meta.nullsAreSortedAtStart(), is(false)); - assertThat(meta.nullsAreSortedAtEnd(), is(false)); - assertThat(meta.nullPlusNonNullIsNull(), is(true)); - assertThat(meta.isCatalogAtStart(), is(false)); - assertThat(meta.isReadOnly(), is(equalTo(connection.isReadOnly()))); - assertThat(meta.storesLowerCaseIdentifiers(), is(false)); - assertThat(meta.storesLowerCaseQuotedIdentifiers(), is(false)); - assertThat(meta.storesMixedCaseIdentifiers(), is(true)); - assertThat(meta.storesMixedCaseQuotedIdentifiers(), is(true)); - assertThat(meta.storesUpperCaseIdentifiers(), is(false)); - assertThat(meta.storesUpperCaseQuotedIdentifiers(), is(false)); - assertThat(meta.supportsAlterTableWithAddColumn(), is(true)); - assertThat(meta.supportsAlterTableWithDropColumn(), is(true)); - assertThat(meta.supportsANSI92EntryLevelSQL(), is(false)); - assertThat(meta.supportsANSI92FullSQL(), is(false)); - assertThat(meta.supportsANSI92IntermediateSQL(), is(false)); - assertThat(meta.supportsBatchUpdates(), is(true)); - assertThat(meta.supportsCatalogsInDataManipulation(), is(false)); - assertThat(meta.supportsCatalogsInIndexDefinitions(), is(false)); - assertThat(meta.supportsCatalogsInPrivilegeDefinitions(), is(false)); - assertThat(meta.supportsCatalogsInProcedureCalls(), is(false)); - assertThat(meta.supportsCatalogsInTableDefinitions(), is(false)); - assertThat(meta.supportsColumnAliasing(), is(true)); + assertTrue(meta.doesMaxRowSizeIncludeBlobs()); + assertFalse(meta.generatedKeyAlwaysReturned()); + assertEquals(".", meta.getCatalogSeparator()); + assertEquals("CATALOG", meta.getCatalogTerm()); + assertEquals(DATABASE_MAJOR_VERSION, meta.getDatabaseMajorVersion()); + assertEquals(DATABASE_MINOR_VERSION, meta.getDatabaseMinorVersion()); + assertEquals(DATABASE_PRODUCT_NAME, meta.getDatabaseProductName()); + assertEquals( + DATABASE_MAJOR_VERSION + "." + DATABASE_MINOR_VERSION, meta.getDatabaseProductVersion()); + assertEquals(Connection.TRANSACTION_SERIALIZABLE, meta.getDefaultTransactionIsolation()); + assertEquals("com.google.cloud.spanner.jdbc.JdbcDriver", meta.getDriverName()); + assertEquals("", meta.getExtraNameCharacters()); + assertEquals("`", meta.getIdentifierQuoteString()); + assertEquals(4, meta.getJDBCMajorVersion()); + assertEquals(1, meta.getJDBCMinorVersion()); // Java 7 is JDBC 4.1 + assertEquals(0, meta.getMaxBinaryLiteralLength()); + assertEquals(0, meta.getMaxCatalogNameLength()); + assertEquals(0, meta.getMaxCharLiteralLength()); + assertEquals(128, meta.getMaxColumnNameLength()); + assertEquals(1000, meta.getMaxColumnsInGroupBy()); + assertEquals(16, meta.getMaxColumnsInIndex()); + assertEquals(0, meta.getMaxColumnsInOrderBy()); + assertEquals(0, meta.getMaxColumnsInSelect()); + assertEquals(1024, meta.getMaxColumnsInTable()); + assertEquals(0, meta.getMaxConnections()); + assertEquals(0, meta.getMaxCursorNameLength()); + assertEquals(8000, meta.getMaxIndexLength()); + assertEquals(0, meta.getMaxProcedureNameLength()); + assertEquals(0, meta.getMaxRowSize()); + assertEquals(0, meta.getMaxSchemaNameLength()); + assertEquals(1000000, meta.getMaxStatementLength()); + assertEquals(0, meta.getMaxStatements()); + assertEquals(128, meta.getMaxTableNameLength()); + assertEquals(0, meta.getMaxTablesInSelect()); + assertEquals(0, meta.getMaxUserNameLength()); + assertEquals("PROCEDURE", meta.getProcedureTerm()); + assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, meta.getResultSetHoldability()); + assertEquals(RowIdLifetime.ROWID_UNSUPPORTED, meta.getRowIdLifetime()); + assertEquals("SCHEMA", meta.getSchemaTerm()); + assertEquals("\\", meta.getSearchStringEscape()); + assertEquals(DatabaseMetaData.sqlStateSQL, meta.getSQLStateType()); + assertTrue(meta.locatorsUpdateCopy()); + assertFalse(meta.nullsAreSortedHigh()); + assertTrue(meta.nullsAreSortedLow()); + assertFalse(meta.nullsAreSortedAtStart()); + assertFalse(meta.nullsAreSortedAtEnd()); + assertTrue(meta.nullPlusNonNullIsNull()); + assertFalse(meta.isCatalogAtStart()); + assertEquals(connection.isReadOnly(), meta.isReadOnly()); + assertFalse(meta.storesLowerCaseIdentifiers()); + assertFalse(meta.storesLowerCaseQuotedIdentifiers()); + assertTrue(meta.storesMixedCaseIdentifiers()); + assertTrue(meta.storesMixedCaseQuotedIdentifiers()); + assertFalse(meta.storesUpperCaseIdentifiers()); + assertFalse(meta.storesUpperCaseQuotedIdentifiers()); + assertTrue(meta.supportsAlterTableWithAddColumn()); + assertTrue(meta.supportsAlterTableWithDropColumn()); + assertFalse(meta.supportsANSI92EntryLevelSQL()); + assertFalse(meta.supportsANSI92FullSQL()); + assertFalse(meta.supportsANSI92IntermediateSQL()); + assertTrue(meta.supportsBatchUpdates()); + assertFalse(meta.supportsCatalogsInDataManipulation()); + assertFalse(meta.supportsCatalogsInIndexDefinitions()); + assertFalse(meta.supportsCatalogsInPrivilegeDefinitions()); + assertFalse(meta.supportsCatalogsInProcedureCalls()); + assertFalse(meta.supportsCatalogsInTableDefinitions()); + assertTrue(meta.supportsColumnAliasing()); // Note that the supportsConvert() method indicates whether the server side function CONVERT is // supported, not what the JDBC driver might be able to convert on the client side. - assertThat(meta.supportsConvert(), is(false)); + assertFalse(meta.supportsConvert()); int[] types = new int[] { Types.ARRAY, @@ -201,77 +195,76 @@ public void testTrivialMethods() throws SQLException { }; for (int from : types) { for (int to : types) { - assertThat(meta.supportsConvert(from, to), is(false)); + assertFalse(meta.supportsConvert(from, to)); } } - assertThat(meta.supportsCoreSQLGrammar(), is(false)); - assertThat(meta.supportsCorrelatedSubqueries(), is(true)); - assertThat(meta.supportsDataDefinitionAndDataManipulationTransactions(), is(false)); - assertThat(meta.supportsDataManipulationTransactionsOnly(), is(true)); - assertThat(meta.supportsDifferentTableCorrelationNames(), is(false)); - assertThat(meta.supportsExpressionsInOrderBy(), is(true)); - assertThat(meta.supportsExtendedSQLGrammar(), is(false)); - assertThat(meta.supportsFullOuterJoins(), is(true)); - assertThat(meta.supportsGetGeneratedKeys(), is(false)); - assertThat(meta.supportsGroupBy(), is(true)); - assertThat(meta.supportsGroupByBeyondSelect(), is(true)); - assertThat(meta.supportsGroupByUnrelated(), is(true)); - assertThat(meta.supportsIntegrityEnhancementFacility(), is(false)); - assertThat(meta.supportsLikeEscapeClause(), is(true)); - assertThat(meta.supportsLimitedOuterJoins(), is(true)); - assertThat(meta.supportsMinimumSQLGrammar(), is(false)); - assertThat(meta.supportsMixedCaseIdentifiers(), is(false)); - assertThat(meta.supportsMixedCaseQuotedIdentifiers(), is(false)); - assertThat(meta.supportsMultipleOpenResults(), is(true)); - assertThat(meta.supportsMultipleResultSets(), is(true)); - assertThat(meta.supportsMultipleTransactions(), is(true)); - assertThat(meta.supportsNamedParameters(), is(false)); - assertThat(meta.supportsNonNullableColumns(), is(true)); - assertThat(meta.supportsOpenCursorsAcrossCommit(), is(false)); - assertThat(meta.supportsOpenCursorsAcrossRollback(), is(false)); - assertThat(meta.supportsOpenStatementsAcrossCommit(), is(true)); - assertThat(meta.supportsOpenStatementsAcrossRollback(), is(true)); - assertThat(meta.supportsOrderByUnrelated(), is(true)); - assertThat(meta.supportsOuterJoins(), is(true)); - assertThat(meta.supportsPositionedDelete(), is(false)); - assertThat(meta.supportsPositionedUpdate(), is(false)); + assertFalse(meta.supportsCoreSQLGrammar()); + assertTrue(meta.supportsCorrelatedSubqueries()); + assertFalse(meta.supportsDataDefinitionAndDataManipulationTransactions()); + assertTrue(meta.supportsDataManipulationTransactionsOnly()); + assertFalse(meta.supportsDifferentTableCorrelationNames()); + assertTrue(meta.supportsExpressionsInOrderBy()); + assertFalse(meta.supportsExtendedSQLGrammar()); + assertTrue(meta.supportsFullOuterJoins()); + assertFalse(meta.supportsGetGeneratedKeys()); + assertTrue(meta.supportsGroupBy()); + assertTrue(meta.supportsGroupByBeyondSelect()); + assertTrue(meta.supportsGroupByUnrelated()); + assertFalse(meta.supportsIntegrityEnhancementFacility()); + assertTrue(meta.supportsLikeEscapeClause()); + assertTrue(meta.supportsLimitedOuterJoins()); + assertFalse(meta.supportsMinimumSQLGrammar()); + assertFalse(meta.supportsMixedCaseIdentifiers()); + assertFalse(meta.supportsMixedCaseQuotedIdentifiers()); + assertTrue(meta.supportsMultipleOpenResults()); + assertTrue(meta.supportsMultipleResultSets()); + assertTrue(meta.supportsMultipleTransactions()); + assertFalse(meta.supportsNamedParameters()); + assertTrue(meta.supportsNonNullableColumns()); + assertFalse(meta.supportsOpenCursorsAcrossCommit()); + assertFalse(meta.supportsOpenCursorsAcrossRollback()); + assertTrue(meta.supportsOpenStatementsAcrossCommit()); + assertTrue(meta.supportsOpenStatementsAcrossRollback()); + assertTrue(meta.supportsOrderByUnrelated()); + assertTrue(meta.supportsOuterJoins()); + assertFalse(meta.supportsPositionedDelete()); + assertFalse(meta.supportsPositionedUpdate()); for (int type : new int[] { ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.TYPE_SCROLL_SENSITIVE }) { - assertThat(meta.supportsResultSetType(type), is(type == ResultSet.TYPE_FORWARD_ONLY)); + assertEquals(type == ResultSet.TYPE_FORWARD_ONLY, meta.supportsResultSetType(type)); for (int concur : new int[] {ResultSet.CONCUR_READ_ONLY, ResultSet.CONCUR_UPDATABLE}) { - assertThat( - meta.supportsResultSetConcurrency(type, concur), - is(type == ResultSet.TYPE_FORWARD_ONLY && concur == ResultSet.CONCUR_READ_ONLY)); + assertEquals( + type == ResultSet.TYPE_FORWARD_ONLY && concur == ResultSet.CONCUR_READ_ONLY, + meta.supportsResultSetConcurrency(type, concur)); } } - assertThat(meta.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT), is(true)); - assertThat(meta.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT), is(false)); - assertThat(meta.supportsSavepoints(), is(false)); - assertThat(meta.supportsSchemasInDataManipulation(), is(false)); - assertThat(meta.supportsSchemasInIndexDefinitions(), is(false)); - assertThat(meta.supportsSchemasInPrivilegeDefinitions(), is(false)); - assertThat(meta.supportsSchemasInProcedureCalls(), is(false)); - assertThat(meta.supportsSchemasInTableDefinitions(), is(false)); - assertThat(meta.supportsSelectForUpdate(), is(false)); - assertThat(meta.supportsStatementPooling(), is(false)); - assertThat(meta.supportsStoredFunctionsUsingCallSyntax(), is(false)); - assertThat(meta.supportsStoredProcedures(), is(false)); - assertThat(meta.supportsSubqueriesInComparisons(), is(true)); - assertThat(meta.supportsSubqueriesInExists(), is(true)); - assertThat(meta.supportsSubqueriesInIns(), is(true)); - assertThat(meta.supportsSubqueriesInQuantifieds(), is(true)); - assertThat(meta.supportsTableCorrelationNames(), is(true)); - assertThat(meta.supportsTransactions(), is(true)); - assertThat(meta.supportsUnion(), is(true)); - assertThat(meta.supportsUnionAll(), is(true)); - assertThat(meta.usesLocalFiles(), is(false)); - assertThat(meta.usesLocalFilePerTable(), is(false)); - assertThat( - meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE), is(true)); + assertTrue(meta.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT)); + assertFalse(meta.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT)); + assertFalse(meta.supportsSavepoints()); + assertFalse(meta.supportsSchemasInDataManipulation()); + assertFalse(meta.supportsSchemasInIndexDefinitions()); + assertFalse(meta.supportsSchemasInPrivilegeDefinitions()); + assertFalse(meta.supportsSchemasInProcedureCalls()); + assertFalse(meta.supportsSchemasInTableDefinitions()); + assertFalse(meta.supportsSelectForUpdate()); + assertFalse(meta.supportsStatementPooling()); + assertFalse(meta.supportsStoredFunctionsUsingCallSyntax()); + assertFalse(meta.supportsStoredProcedures()); + assertTrue(meta.supportsSubqueriesInComparisons()); + assertTrue(meta.supportsSubqueriesInExists()); + assertTrue(meta.supportsSubqueriesInIns()); + assertTrue(meta.supportsSubqueriesInQuantifieds()); + assertTrue(meta.supportsTableCorrelationNames()); + assertTrue(meta.supportsTransactions()); + assertTrue(meta.supportsUnion()); + assertTrue(meta.supportsUnionAll()); + assertFalse(meta.usesLocalFiles()); + assertFalse(meta.usesLocalFilePerTable()); + assertTrue(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE)); for (int level : new int[] { Connection.TRANSACTION_NONE, @@ -279,17 +272,17 @@ public void testTrivialMethods() throws SQLException { Connection.TRANSACTION_READ_UNCOMMITTED, Connection.TRANSACTION_REPEATABLE_READ }) { - assertThat(meta.supportsTransactionIsolationLevel(level), is(false)); + assertFalse(meta.supportsTransactionIsolationLevel(level)); } assertEquals(10485760L, meta.getMaxLogicalLobSize()); assertFalse(meta.supportsRefCursors()); // trivial tests that guarantee that the function works, but the return value doesn't matter - assertThat(meta.getNumericFunctions(), is(notNullValue())); - assertThat(meta.getSQLKeywords(), is(notNullValue())); - assertThat(meta.getStringFunctions(), is(notNullValue())); - assertThat(meta.getSystemFunctions(), is(notNullValue())); - assertThat(meta.getTimeDateFunctions(), is(notNullValue())); + assertNotNull(meta.getNumericFunctions()); + assertNotNull(meta.getSQLKeywords()); + assertNotNull(meta.getStringFunctions()); + assertNotNull(meta.getSystemFunctions()); + assertNotNull(meta.getTimeDateFunctions()); } @Test @@ -297,9 +290,9 @@ public void testGetAttributes() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getAttributes(DEFAULT_CATALOG, DEFAULT_SCHEMA, TEST_TABLE, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(21))); + assertEquals(21, rsmd.getColumnCount()); } } @@ -314,9 +307,9 @@ public void testGetBestRowIdentifier() throws SQLException { TEST_TABLE, DatabaseMetaData.bestRowTransaction, false)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(8))); + assertEquals(8, rsmd.getColumnCount()); } } @@ -327,11 +320,11 @@ public void testGetCatalogs() throws SQLException { when(connection.getCatalog()).thenCallRealMethod(); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getCatalogs()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_CAT"), is(equalTo(connection.getDefaultCatalog()))); - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(connection.getDefaultCatalog(), rs.getString("TABLE_CAT")); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(1))); + assertEquals(1, rsmd.getColumnCount()); } } @@ -340,21 +333,21 @@ public void testGetClientInfoProperties() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getClientInfoProperties()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("NAME"), is(equalTo("APPLICATIONNAME"))); - assertThat(rs.getString("DEFAULT_VALUE"), is(equalTo(""))); + assertTrue(rs.next()); + assertEquals("APPLICATIONNAME", rs.getString("NAME")); + assertEquals("", rs.getString("DEFAULT_VALUE")); - assertThat(rs.next(), is(true)); - assertThat(rs.getString("NAME"), is(equalTo("CLIENTHOSTNAME"))); - assertThat(rs.getString("DEFAULT_VALUE"), is(equalTo(""))); + assertTrue(rs.next()); + assertEquals("CLIENTHOSTNAME", rs.getString("NAME")); + assertEquals("", rs.getString("DEFAULT_VALUE")); - assertThat(rs.next(), is(true)); - assertThat(rs.getString("NAME"), is(equalTo("CLIENTUSER"))); - assertThat(rs.getString("DEFAULT_VALUE"), is(equalTo(""))); + assertTrue(rs.next()); + assertEquals("CLIENTUSER", rs.getString("NAME")); + assertEquals("", rs.getString("DEFAULT_VALUE")); - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(4))); + assertEquals(4, rsmd.getColumnCount()); } } @@ -364,9 +357,9 @@ public void testGetColumnPrivileges() throws SQLException { DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getColumnPrivileges(DEFAULT_CATALOG, DEFAULT_SCHEMA, TEST_TABLE, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(8))); + assertEquals(8, rsmd.getColumnCount()); } } @@ -375,9 +368,9 @@ public void testGetFunctionColumns() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getFunctionColumns(DEFAULT_CATALOG, DEFAULT_SCHEMA, null, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(17))); + assertEquals(17, rsmd.getColumnCount()); } } @@ -386,9 +379,9 @@ public void testGetFunctions() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getFunctions(DEFAULT_CATALOG, DEFAULT_SCHEMA, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(6))); + assertEquals(6, rsmd.getColumnCount()); } } @@ -397,9 +390,9 @@ public void testGetProcedureColumns() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getProcedureColumns(DEFAULT_CATALOG, DEFAULT_SCHEMA, null, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(20))); + assertEquals(20, rsmd.getColumnCount()); } } @@ -408,9 +401,9 @@ public void testGetProcedures() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getProcedures(DEFAULT_CATALOG, DEFAULT_SCHEMA, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(9))); + assertEquals(9, rsmd.getColumnCount()); } } @@ -419,9 +412,9 @@ public void testGetPseudoColumns() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getPseudoColumns(DEFAULT_CATALOG, DEFAULT_SCHEMA, TEST_TABLE, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(12))); + assertEquals(12, rsmd.getColumnCount()); } } @@ -430,9 +423,9 @@ public void testGetSuperTables() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getSuperTables(DEFAULT_CATALOG, DEFAULT_SCHEMA, TEST_TABLE)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(4))); + assertEquals(4, rsmd.getColumnCount()); } } @@ -441,9 +434,9 @@ public void testGetSuperTypes() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getSuperTypes(DEFAULT_CATALOG, DEFAULT_SCHEMA, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(6))); + assertEquals(6, rsmd.getColumnCount()); } } @@ -452,9 +445,9 @@ public void testGetTablePrivileges() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getTablePrivileges(DEFAULT_CATALOG, DEFAULT_SCHEMA, TEST_TABLE)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(7))); + assertEquals(7, rsmd.getColumnCount()); } } @@ -463,13 +456,13 @@ public void testGetTableTypes() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getTableTypes()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_TYPE"), is(equalTo("TABLE"))); - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_TYPE"), is(equalTo("VIEW"))); - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals("TABLE", rs.getString("TABLE_TYPE")); + assertTrue(rs.next()); + assertEquals("VIEW", rs.getString("TABLE_TYPE")); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(1))); + assertEquals(1, rsmd.getColumnCount()); } } @@ -500,9 +493,9 @@ public void testGetTypeInfo() throws SQLException { assertEquals("NUMERIC", rs.getString("TYPE_NAME")); assertTrue(rs.next()); assertEquals(dialect == Dialect.POSTGRESQL ? "JSONB" : "JSON", rs.getString("TYPE_NAME")); - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(18))); + assertEquals(18, rsmd.getColumnCount()); } } } @@ -512,9 +505,9 @@ public void testGetUDTs() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getUDTs(DEFAULT_CATALOG, DEFAULT_SCHEMA, null, null)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(7))); + assertEquals(7, rsmd.getColumnCount()); } } @@ -523,9 +516,9 @@ public void testGetVersionColumns() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); try (ResultSet rs = meta.getVersionColumns(DEFAULT_CATALOG, DEFAULT_SCHEMA, TEST_TABLE)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); - assertThat(rsmd.getColumnCount(), is(equalTo(8))); + assertEquals(8, rsmd.getColumnCount()); } } @@ -540,6 +533,6 @@ public void testGetUserName() throws SQLException, IOException { when(options.getCredentials()).thenReturn(credentials); when(connection.getConnectionOptions()).thenReturn(options); DatabaseMetaData meta = new JdbcDatabaseMetaData(connection); - assertThat(meta.getUserName(), is(equalTo("test@test-project.iam.gserviceaccount.com"))); + assertEquals("test@test-project.iam.gserviceaccount.com", meta.getUserName()); } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcExceptionMatcher.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcExceptionMatcher.java deleted file mode 100644 index afe9657f0..000000000 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcExceptionMatcher.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright 2019 Google LLC - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.google.cloud.spanner.jdbc; - -import com.google.common.base.Preconditions; -import com.google.rpc.Code; -import org.hamcrest.BaseMatcher; -import org.hamcrest.Description; - -public final class JdbcExceptionMatcher extends BaseMatcher { - private final Code errorCode; - private final String message; - - public static JdbcExceptionMatcher matchCode(Code errorCode) { - Preconditions.checkNotNull(errorCode); - return new JdbcExceptionMatcher(errorCode, null); - } - - public static JdbcExceptionMatcher matchCodeAndMessage(Code errorCode, String message) { - Preconditions.checkNotNull(errorCode); - Preconditions.checkNotNull(message); - return new JdbcExceptionMatcher(errorCode, message); - } - - private JdbcExceptionMatcher(Code errorCode, String message) { - this.errorCode = errorCode; - this.message = message; - } - - @Override - public boolean matches(Object item) { - if (item instanceof JdbcSqlException) { - JdbcSqlException exception = (JdbcSqlException) item; - if (message == null) { - return exception.getCode().equals(errorCode); - } - return exception.getCode().equals(errorCode) - && exception.getMessage().equals(errorCode.name() + ": " + message); - } - return false; - } - - @Override - public void describeTo(Description description) { - description.appendText(JdbcSqlException.class.getName() + " with code " + errorCode.name()); - if (message != null) { - description.appendText(" - " + JdbcSqlException.class.getName() + " with message " + message); - } - } -} diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcGrpcErrorTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcGrpcErrorTest.java index 2c1bfe820..ba94647cb 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcGrpcErrorTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcGrpcErrorTest.java @@ -16,8 +16,9 @@ package com.google.cloud.spanner.jdbc; -import static com.google.common.truth.Truth.assertThat; -import static org.junit.Assert.fail; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import com.google.cloud.spanner.ErrorCode; import com.google.cloud.spanner.MockSpannerServiceImpl; @@ -87,9 +88,6 @@ public class JdbcGrpcErrorTest { // FAILED_PRECONDITION is chosen as the test error code as it should never be retryable. private final Exception serverException = Status.FAILED_PRECONDITION.withDescription("test exception").asRuntimeException(); - private final SpannerJdbcExceptionMatcher testExceptionMatcher = - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, Code.FAILED_PRECONDITION, "test exception"); @BeforeClass public static void startStaticServer() throws IOException { @@ -152,69 +150,79 @@ private Connection createConnection() throws SQLException { } @Test - public void autocommitBeginTransaction() { + public void autocommitBeginTransaction() throws SQLException { mockSpanner.setBeginTransactionExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { // This triggers a retry with an explicit BeginTransaction RPC. mockSpanner.abortNextStatement(); - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void autocommitBeginPDMLTransaction() { + public void autocommitBeginPDMLTransaction() throws SQLException { mockSpanner.setBeginTransactionExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.createStatement().execute("SET AUTOCOMMIT_DML_MODE='PARTITIONED_NON_ATOMIC'"); - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void transactionalBeginTransaction() { + public void transactionalBeginTransaction() throws SQLException { mockSpanner.setBeginTransactionExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); // This triggers a retry with an explicit BeginTransaction RPC. mockSpanner.abortNextStatement(); - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void readOnlyBeginTransaction() { + public void readOnlyBeginTransaction() throws SQLException { mockSpanner.setBeginTransactionExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); connection.setReadOnly(true); - connection.createStatement().executeQuery(SELECT1.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeQuery(SELECT1.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void autocommitExecuteSql() { + public void autocommitExecuteSql() throws SQLException { mockSpanner.setExecuteSqlExecutionTime(SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @@ -230,22 +238,26 @@ public void autocommitPDMLExecuteSql() throws SQLException { SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.createStatement().execute("SET AUTOCOMMIT_DML_MODE='PARTITIONED_NON_ATOMIC'"); - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void transactionalExecuteSql() { + public void transactionalExecuteSql() throws SQLException { mockSpanner.setExecuteSqlExecutionTime(SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @@ -257,10 +269,10 @@ public void autocommitExecuteBatchDml() throws SQLException { try (java.sql.Statement statement = connection.createStatement()) { statement.addBatch(UPDATE_STATEMENT.getSql()); statement.addBatch(UPDATE_STATEMENT.getSql()); - statement.executeBatch(); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, statement::executeBatch); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } } @@ -274,52 +286,53 @@ public void transactionalExecuteBatchDml() throws SQLException { try (java.sql.Statement statement = connection.createStatement()) { statement.addBatch(UPDATE_STATEMENT.getSql()); statement.addBatch(UPDATE_STATEMENT.getSql()); - statement.executeBatch(); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, statement::executeBatch); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } } @Test - public void autocommitCommit() { + public void autocommitCommit() throws SQLException { mockSpanner.setCommitExecutionTime(SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void transactionalCommit() { + public void transactionalCommit() throws SQLException { mockSpanner.setCommitExecutionTime(SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - connection.commit(); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, connection::commit); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void autocommitRollback() { + public void autocommitRollback() throws SQLException { // The JDBC driver should throw the exception of the SQL statement and ignore any errors from // the rollback() method. mockSpanner.setRollbackExecutionTime(SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { - connection.createStatement().executeUpdate(INVALID_UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, Code.NOT_FOUND, "Unknown table name") - .matches(e)) - .isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(INVALID_UPDATE_STATEMENT.getSql())); + assertEquals(Code.NOT_FOUND, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), sqlException.getMessage().contains("Unknown table name")); } } @@ -346,82 +359,88 @@ public void autocommitExecuteStreamingSql() throws SQLException { mockSpanner.setExecuteStreamingSqlExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { - try (java.sql.ResultSet rs = connection.createStatement().executeQuery(SELECT1.getSql())) { - rs.next(); - fail("missing expected exception"); - } - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeQuery(SELECT1.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void transactionalExecuteStreamingSql() { + public void transactionalExecuteStreamingSql() throws SQLException { mockSpanner.setExecuteStreamingSqlExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); - try (java.sql.ResultSet rs = connection.createStatement().executeQuery(SELECT1.getSql())) { - rs.next(); - fail("missing expected exception"); - } - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeQuery(SELECT1.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void readOnlyExecuteStreamingSql() { + public void readOnlyExecuteStreamingSql() throws SQLException { mockSpanner.setExecuteStreamingSqlExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); connection.setReadOnly(true); - try (java.sql.ResultSet rs = connection.createStatement().executeQuery(SELECT1.getSql())) { - rs.next(); - fail("missing expected exception"); - } - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeQuery(SELECT1.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void autocommitCreateSession() { + public void autocommitCreateSession() throws SQLException { mockSpanner.setBatchCreateSessionsExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void transactionalCreateSession() { + public void transactionalCreateSession() throws SQLException { mockSpanner.setBatchCreateSessionsExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); - connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeUpdate(UPDATE_STATEMENT.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } @Test - public void readOnlyCreateSession() { + public void readOnlyCreateSession() throws SQLException { mockSpanner.setBatchCreateSessionsExecutionTime( SimulatedExecutionTime.ofException(serverException)); try (java.sql.Connection connection = createConnection()) { connection.setAutoCommit(false); connection.setReadOnly(true); - connection.createStatement().executeQuery(SELECT1.getSql()); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(testExceptionMatcher.matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> connection.createStatement().executeQuery(SELECT1.getSql())); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("test exception")); } } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcResultSetTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcResultSetTest.java index 08bc7e060..67b0cfd23 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcResultSetTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcResultSetTest.java @@ -16,12 +16,12 @@ package com.google.cloud.spanner.jdbc; -import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.Mockito.mock; @@ -497,18 +497,14 @@ public void testGetURLIndex() throws SQLException, MalformedURLException { @Test public void testGetURLIndexInvalid() throws SQLException { - try { - subject.getURL(STRING_COLINDEX_NOTNULL); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, - Code.INVALID_ARGUMENT, - "Invalid URL: " + subject.getString(STRING_COLINDEX_NOTNULL)) - .matches(e)) - .isTrue(); - } + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> subject.getURL(STRING_COLINDEX_NOTNULL)); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException + .getMessage() + .contains("Invalid URL: " + subject.getString(STRING_COLINDEX_NOTNULL))); } @Test @@ -901,18 +897,14 @@ public void testGetURLLabel() throws SQLException { @Test public void testGetURLLabelInvalid() throws SQLException { - try { - subject.getURL(STRING_COL_NOT_NULL); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, - Code.INVALID_ARGUMENT, - "Invalid URL: " + subject.getString(STRING_COL_NOT_NULL)) - .matches(e)) - .isTrue(); - } + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> subject.getURL(STRING_COL_NOT_NULL)); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException + .getMessage() + .contains("Invalid URL: " + subject.getString(STRING_COL_NOT_NULL))); } @Test @@ -1754,52 +1746,40 @@ public void testGetBinaryStreamLabel() throws SQLException, IOException { @Test public void testGetBeforeNext() { try (JdbcResultSet rs = JdbcResultSet.of(mock(Statement.class), getMockResultSet())) { - rs.getBigDecimal(LONG_COLINDEX_NOTNULL); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, - Code.FAILED_PRECONDITION, - "ResultSet is before first row. Call next() first.") - .matches(e)) - .isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> rs.getBigDecimal(LONG_COLINDEX_NOTNULL)); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException.getMessage().contains("ResultSet is before first row. Call next() first.")); } } @Test - public void testGetAfterLast() { + public void testGetAfterLast() throws SQLException { try (JdbcResultSet rs = JdbcResultSet.of(mock(Statement.class), getMockResultSet())) { while (rs.next()) { assertNotNull(rs.getBigDecimal(LONG_COLINDEX_NOTNULL)); } - rs.getBigDecimal(LONG_COLINDEX_NOTNULL); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, - Code.FAILED_PRECONDITION, - "ResultSet is after last row. There is no more data available.") - .matches(e)) - .isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> rs.getBigDecimal(LONG_COLINDEX_NOTNULL)); + assertEquals(Code.FAILED_PRECONDITION, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException + .getMessage() + .contains("ResultSet is after last row. There is no more data available.")); } } @Test public void testFindIllegalColumnName() { - try { - subject.findColumn(UNKNOWN_COLUMN); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - SpannerJdbcExceptionMatcher.matchCodeAndMessage( - JdbcSqlExceptionImpl.class, - Code.INVALID_ARGUMENT, - "no column with label " + UNKNOWN_COLUMN + " found") - .matches(e)) - .isTrue(); - } + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> subject.findColumn(UNKNOWN_COLUMN)); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException.getMessage().contains("no column with label " + UNKNOWN_COLUMN + " found")); } @Test diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcStatementTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcStatementTest.java index 727e63acf..cb4cc5a53 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcStatementTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcStatementTest.java @@ -300,16 +300,12 @@ public void testExecuteQuery() throws SQLException { } @Test - public void testExecuteQueryWithUpdateStatement() { - try { - Statement statement = createStatement(); - statement.executeQuery(UPDATE); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - JdbcExceptionMatcher.matchCodeAndMessage(Code.INVALID_ARGUMENT, "not a query") - .matches(e)) - .isTrue(); + public void testExecuteQueryWithUpdateStatement() throws SQLException { + try (Statement statement = createStatement()) { + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> statement.executeQuery(UPDATE)); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("not a query")); } } @@ -325,28 +321,22 @@ public void testExecuteQueryWithDmlReturningStatement() throws SQLException { } @Test - public void testExecuteQueryWithDdlStatement() { - try { - Statement statement = createStatement(); - statement.executeQuery(DDL); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - JdbcExceptionMatcher.matchCodeAndMessage(Code.INVALID_ARGUMENT, "not a query") - .matches(e)) - .isTrue(); + public void testExecuteQueryWithDdlStatement() throws SQLException { + try (Statement statement = createStatement()) { + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> statement.executeQuery(DDL)); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue(sqlException.getMessage(), sqlException.getMessage().contains("not a query")); } } @Test public void testExecuteUpdate() throws SQLException { - Statement statement = createStatement(); - assertThat(statement.executeUpdate(UPDATE)).isEqualTo(1); - try { - statement.executeUpdate(LARGE_UPDATE); - fail("missing expected exception"); - } catch (JdbcSqlExceptionImpl e) { - assertThat(e.getCode()).isEqualTo(Code.OUT_OF_RANGE); + try (Statement statement = createStatement()) { + assertEquals(1, statement.executeUpdate(UPDATE)); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> statement.executeUpdate(LARGE_UPDATE)); + assertEquals(Code.OUT_OF_RANGE, sqlException.getCode()); } } @@ -423,34 +413,31 @@ public void testExecuteLargeUpdate() throws SQLException { } @Test - public void testExecuteUpdateWithSelectStatement() { - try { - Statement statement = createStatement(); - statement.executeUpdate(SELECT); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - JdbcExceptionMatcher.matchCodeAndMessage( - Code.INVALID_ARGUMENT, - "The statement is not a non-returning DML or DDL statement") - .matches(e)) - .isTrue(); + public void testExecuteUpdateWithSelectStatement() throws SQLException { + try (Statement statement = createStatement()) { + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> statement.executeUpdate(SELECT)); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException + .getMessage() + .contains("The statement is not a non-returning DML or DDL statement")); } } @Test - public void testExecuteUpdateWithDmlReturningStatement() { - try { - Statement statement = createStatement(); - SQLException e = - assertThrows(SQLException.class, () -> statement.executeUpdate(getDmlReturningSql())); + public void testExecuteUpdateWithDmlReturningStatement() throws SQLException { + try (Statement statement = createStatement()) { + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, () -> statement.executeUpdate(getDmlReturningSql())); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); assertTrue( - JdbcExceptionMatcher.matchCodeAndMessage( - Code.INVALID_ARGUMENT, - "The statement is not a non-returning DML or DDL statement") - .matches(e)); - } catch (SQLException e) { - // ignore exception. + sqlException.getMessage(), + sqlException + .getMessage() + .contains("The statement is not a non-returning DML or DDL statement")); } } @@ -490,32 +477,36 @@ public void testMoreResults() throws SQLException { } @Test - public void testNoBatchMixing() { + public void testNoBatchMixing() throws SQLException { try (Statement statement = createStatement()) { statement.addBatch("INSERT INTO FOO (ID, NAME) VALUES (1, 'FOO')"); - statement.addBatch("CREATE TABLE FOO (ID INT64, NAME STRING(100)) PRIMARY KEY (ID)"); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat( - JdbcExceptionMatcher.matchCodeAndMessage( - Code.INVALID_ARGUMENT, - "Mixing DML and DDL statements in a batch is not allowed.") - .matches(e)) - .isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> + statement.addBatch( + "CREATE TABLE FOO (ID INT64, NAME STRING(100)) PRIMARY KEY (ID)")); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException + .getMessage() + .contains("Mixing DML and DDL statements in a batch is not allowed.")); } } @Test - public void testNoBatchQuery() { + public void testNoBatchQuery() throws SQLException { try (Statement statement = createStatement()) { - statement.addBatch("SELECT * FROM FOO"); - } catch (SQLException e) { - assertThat( - JdbcExceptionMatcher.matchCodeAndMessage( - Code.INVALID_ARGUMENT, - "The statement is not suitable for batching. Only DML and DDL statements are allowed for batching.") - .matches(e)) - .isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows(JdbcSqlExceptionImpl.class, () -> statement.addBatch("SELECT * FROM FOO")); + assertEquals(Code.INVALID_ARGUMENT, sqlException.getCode()); + assertTrue( + sqlException.getMessage(), + sqlException + .getMessage() + .contains( + "The statement is not suitable for batching. Only DML and DDL statements are allowed for batching.")); } } @@ -559,7 +550,7 @@ public void testLargeDmlBatch() throws SQLException { } @Test - public void testConvertUpdateCounts() { + public void testConvertUpdateCounts() throws SQLException { JdbcConnection connection = mock(JdbcConnection.class); when(connection.getDialect()).thenReturn(dialect); try (JdbcStatement statement = new JdbcStatement(connection)) { @@ -568,10 +559,11 @@ public void testConvertUpdateCounts() { updateCounts = statement.convertUpdateCounts(new long[] {0L, 0L, 0L}); assertThat(updateCounts).asList().containsExactly(0, 0, 0); - statement.convertUpdateCounts(new long[] {1L, Integer.MAX_VALUE + 1L}); - fail("missing expected exception"); - } catch (SQLException e) { - assertThat(JdbcExceptionMatcher.matchCode(Code.OUT_OF_RANGE).matches(e)).isTrue(); + JdbcSqlExceptionImpl sqlException = + assertThrows( + JdbcSqlExceptionImpl.class, + () -> statement.convertUpdateCounts(new long[] {1L, Integer.MAX_VALUE + 1L})); + assertEquals(Code.OUT_OF_RANGE, sqlException.getCode()); } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/SpannerJdbcExceptionMatcher.java b/src/test/java/com/google/cloud/spanner/jdbc/SpannerJdbcExceptionMatcher.java deleted file mode 100644 index 062a5ac42..000000000 --- a/src/test/java/com/google/cloud/spanner/jdbc/SpannerJdbcExceptionMatcher.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright 2019 Google LLC - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.google.cloud.spanner.jdbc; - -import com.google.common.base.Preconditions; -import com.google.rpc.Code; -import org.hamcrest.BaseMatcher; -import org.hamcrest.Description; - -public final class SpannerJdbcExceptionMatcher extends BaseMatcher { - private final Class exceptionClass; - private final Code errorCode; - private final String message; - - public static SpannerJdbcExceptionMatcher matchCode( - Class exceptionClass, Code errorCode) { - Preconditions.checkNotNull(exceptionClass); - Preconditions.checkNotNull(errorCode); - return new SpannerJdbcExceptionMatcher<>(exceptionClass, errorCode, null); - } - - public static SpannerJdbcExceptionMatcher matchCodeAndMessage( - Class exceptionClass, Code errorCode, String message) { - Preconditions.checkNotNull(exceptionClass); - Preconditions.checkNotNull(errorCode); - Preconditions.checkNotNull(message); - return new SpannerJdbcExceptionMatcher<>(exceptionClass, errorCode, message); - } - - private SpannerJdbcExceptionMatcher(Class exceptionClass, Code errorCode, String message) { - this.exceptionClass = exceptionClass; - this.errorCode = errorCode; - this.message = message; - } - - @Override - public boolean matches(Object item) { - if (exceptionClass.isAssignableFrom(item.getClass())) { - JdbcSqlException exception = (JdbcSqlException) item; - if (message == null) { - return exception.getErrorCode() == errorCode.getNumber(); - } - return exception.getErrorCode() == errorCode.getNumber() - && exception.getMessage().contains(": " + message); - } - return false; - } - - @Override - public void describeTo(Description description) { - description.appendText(exceptionClass.getName() + " with code " + errorCode.name()); - if (message != null) { - description.appendText(" - " + JdbcSqlException.class.getName() + " with message " + message); - } - } -} diff --git a/src/test/java/com/google/cloud/spanner/jdbc/it/ITAbstractJdbcTest.java b/src/test/java/com/google/cloud/spanner/jdbc/it/ITAbstractJdbcTest.java index 9391b52af..049d51ca3 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/it/ITAbstractJdbcTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/it/ITAbstractJdbcTest.java @@ -124,9 +124,6 @@ static Collection getMusicTablesDdl(Dialect dialect) { default: scriptFile = "CreateMusicTables.sql"; } - if (dialect != Dialect.POSTGRESQL && isUsingEmulator()) { - scriptFile = "CreateMusicTables_Emulator.sql"; - } return AbstractSqlScriptVerifier.readStatementsFromFile(scriptFile, ITAbstractJdbcTest.class) .stream() .filter(sql -> !(sql.contains("START BATCH") || sql.contains("RUN BATCH"))) diff --git a/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcDatabaseMetaDataTest.java b/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcDatabaseMetaDataTest.java index 820bdfac9..903df91db 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcDatabaseMetaDataTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcDatabaseMetaDataTest.java @@ -16,20 +16,14 @@ package com.google.cloud.spanner.jdbc.it; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import static org.junit.Assume.assumeFalse; import com.google.cloud.spanner.Database; import com.google.cloud.spanner.ParallelIntegrationTest; -import com.google.cloud.spanner.testing.EmulatorSpannerHelper; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.ResultSet; @@ -177,63 +171,59 @@ public void testGetColumns() throws SQLException { .getColumns(DEFAULT_CATALOG, DEFAULT_SCHEMA, TABLE_WITH_ALL_COLS, null)) { int pos = 1; for (Column col : EXPECTED_COLUMNS) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("TABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("COLUMN_NAME"), is(equalTo(col.name))); - assertThat(rs.getInt("DATA_TYPE"), is(equalTo(col.type))); - assertThat(rs.getString("TYPE_NAME"), is(equalTo(col.typeName))); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("TABLE_NAME")); + assertEquals(col.name, rs.getString("COLUMN_NAME")); + assertEquals(col.type, rs.getInt("DATA_TYPE")); + assertEquals(col.typeName, rs.getString("TYPE_NAME")); if (col.colSize == null) { - assertThat(rs.getInt("COLUMN_SIZE"), is(equalTo(0))); - assertThat(rs.wasNull(), is(true)); + assertEquals(0, rs.getInt("COLUMN_SIZE")); + assertTrue(rs.wasNull()); } else { - assertThat(rs.getInt("COLUMN_SIZE"), is(equalTo(col.colSize))); + assertEquals(col.colSize.intValue(), rs.getInt("COLUMN_SIZE")); } rs.getObject("BUFFER_LENGTH"); // just assert that it exists if (col.decimalDigits == null) { - assertThat(rs.getInt("DECIMAL_DIGITS"), is(equalTo(0))); - assertThat(rs.wasNull(), is(true)); + assertEquals(0, rs.getInt("DECIMAL_DIGITS")); + assertTrue(rs.wasNull()); } else { - assertThat(rs.getInt("DECIMAL_DIGITS"), is(equalTo(col.decimalDigits))); + assertEquals(col.decimalDigits.intValue(), rs.getInt("DECIMAL_DIGITS")); } if (col.radix == null) { - assertThat(rs.getInt("NUM_PREC_RADIX"), is(equalTo(0))); - assertThat(rs.wasNull(), is(true)); + assertEquals(0, rs.getInt("NUM_PREC_RADIX")); + assertTrue(rs.wasNull()); } else { - assertThat(rs.getInt("NUM_PREC_RADIX"), is(equalTo(col.radix))); + assertEquals(col.radix.intValue(), rs.getInt("NUM_PREC_RADIX")); } - assertThat( - rs.getInt("NULLABLE"), - is( - equalTo( - col.nullable - ? DatabaseMetaData.columnNullable - : DatabaseMetaData.columnNoNulls))); - assertThat(rs.getString("REMARKS"), is(nullValue())); - assertThat(rs.getString("COLUMN_DEF"), is(nullValue())); - assertThat(rs.getInt("SQL_DATA_TYPE"), is(equalTo(0))); - assertThat(rs.getInt("SQL_DATETIME_SUB"), is(equalTo(0))); + assertEquals( + col.nullable ? DatabaseMetaData.columnNullable : DatabaseMetaData.columnNoNulls, + rs.getInt("NULLABLE")); + assertNull(rs.getString("REMARKS")); + assertNull(rs.getString("COLUMN_DEF")); + assertEquals(0, rs.getInt("SQL_DATA_TYPE")); + assertEquals(0, rs.getInt("SQL_DATETIME_SUB")); if (col.charOctetLength == null) { - assertThat(rs.getInt("CHAR_OCTET_LENGTH"), is(equalTo(0))); - assertThat(rs.wasNull(), is(true)); + assertEquals(0, rs.getInt("CHAR_OCTET_LENGTH")); + assertTrue(rs.wasNull()); } else { - assertThat(rs.getInt("CHAR_OCTET_LENGTH"), is(equalTo(col.charOctetLength))); + assertEquals(col.charOctetLength.intValue(), rs.getInt("CHAR_OCTET_LENGTH")); } - assertThat(rs.getInt("ORDINAL_POSITION"), is(equalTo(pos))); - assertThat(rs.getString("IS_NULLABLE"), is(equalTo(col.nullable ? "YES" : "NO"))); - assertThat(rs.getString("SCOPE_CATALOG"), is(nullValue())); - assertThat(rs.getString("SCOPE_SCHEMA"), is(nullValue())); - assertThat(rs.getString("SCOPE_TABLE"), is(nullValue())); - assertThat(rs.getShort("SOURCE_DATA_TYPE"), is(equalTo((short) 0))); - assertThat(rs.wasNull(), is(true)); - assertThat(rs.getString("IS_AUTOINCREMENT"), is(equalTo("NO"))); - assertThat(rs.getString("IS_GENERATEDCOLUMN"), is(equalTo(col.computed ? "YES" : "NO"))); - assertThat(rs.getMetaData().getColumnCount(), is(equalTo(24))); + assertEquals(pos, rs.getInt("ORDINAL_POSITION")); + assertEquals(col.nullable ? "YES" : "NO", rs.getString("IS_NULLABLE")); + assertNull(rs.getString("SCOPE_CATALOG")); + assertNull(rs.getString("SCOPE_SCHEMA")); + assertNull(rs.getString("SCOPE_TABLE")); + assertEquals(0, rs.getShort("SOURCE_DATA_TYPE")); + assertTrue(rs.wasNull()); + assertEquals("NO", rs.getString("IS_AUTOINCREMENT")); + assertEquals(col.computed ? "YES" : "NO", rs.getString("IS_GENERATEDCOLUMN")); + assertEquals(24, rs.getMetaData().getColumnCount()); pos++; } - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); } } } @@ -251,25 +241,21 @@ public void testGetCrossReferences() throws SQLException { DEFAULT_CATALOG, DEFAULT_SCHEMA, ALBUMS_TABLE)) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo("Singers"))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo("Albums"))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals("Singers", rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals("Albums", rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getShort("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); } try (ResultSet rs = connection @@ -281,45 +267,37 @@ public void testGetCrossReferences() throws SQLException { DEFAULT_CATALOG, DEFAULT_SCHEMA, SONGS_TABLE)) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo("Albums"))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo("Songs"))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo("Albums"))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("AlbumId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo("Songs"))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("AlbumId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 2))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals("Albums", rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals("Songs", rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getShort("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals("Albums", rs.getString("PKTABLE_NAME")); + assertEquals("AlbumId", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals("Songs", rs.getString("FKTABLE_NAME")); + assertEquals("AlbumId", rs.getString("FKCOLUMN_NAME")); + assertEquals(2, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getShort("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); } try (ResultSet rs = @@ -332,26 +310,22 @@ public void testGetCrossReferences() throws SQLException { DEFAULT_CATALOG, DEFAULT_SCHEMA, CONCERTS_TABLE)) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo("Singers"))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo("Concerts"))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat(rs.getString("FK_NAME"), is(equalTo("Fk_Concerts_Singer"))); - assertThat(rs.getString("PK_NAME"), is(equalTo("PK_Singers"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals("Singers", rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals("Concerts", rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("DELETE_RULE")); + assertEquals("Fk_Concerts_Singer", rs.getString("FK_NAME")); + assertEquals("PK_Singers", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); + assertFalse(rs.next()); } try (ResultSet rs = @@ -365,64 +339,52 @@ public void testGetCrossReferences() throws SQLException { DEFAULT_SCHEMA, TABLE_WITH_REF)) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("ColFloat64"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(TABLE_WITH_REF))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("RefFloat"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat(rs.getString("FK_NAME"), is(equalTo("Fk_TableWithRef_TableWithAllColumnTypes"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("ColString"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(TABLE_WITH_REF))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("RefString"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 2))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat(rs.getString("FK_NAME"), is(equalTo("Fk_TableWithRef_TableWithAllColumnTypes"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("ColDate"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(""))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(TABLE_WITH_REF))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("RefDate"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 3))); - assertThat( - rs.getShort("UPDATE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat( - rs.getShort("DELETE_RULE"), is(equalTo((short) DatabaseMetaData.importedKeyNoAction))); - assertThat(rs.getString("FK_NAME"), is(equalTo("Fk_TableWithRef_TableWithAllColumnTypes"))); - assertThat( - rs.getShort("DEFERRABILITY"), - is(equalTo((short) DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("PKTABLE_NAME")); + assertEquals("ColFloat64", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals(TABLE_WITH_REF, rs.getString("FKTABLE_NAME")); + assertEquals("RefFloat", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("DELETE_RULE")); + assertEquals("Fk_TableWithRef_TableWithAllColumnTypes", rs.getString("FK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("PKTABLE_NAME")); + assertEquals("ColString", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals(TABLE_WITH_REF, rs.getString("FKTABLE_NAME")); + assertEquals("RefString", rs.getString("FKCOLUMN_NAME")); + assertEquals(2, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("DELETE_RULE")); + assertEquals("Fk_TableWithRef_TableWithAllColumnTypes", rs.getString("FK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals("", rs.getString("PKTABLE_CAT")); + assertEquals("", rs.getString("PKTABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("PKTABLE_NAME")); + assertEquals("ColDate", rs.getString("PKCOLUMN_NAME")); + assertEquals("", rs.getString("FKTABLE_CAT")); + assertEquals("", rs.getString("FKTABLE_SCHEM")); + assertEquals(TABLE_WITH_REF, rs.getString("FKTABLE_NAME")); + assertEquals("RefDate", rs.getString("FKCOLUMN_NAME")); + assertEquals(3, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyNoAction, rs.getShort("DELETE_RULE")); + assertEquals("Fk_TableWithRef_TableWithAllColumnTypes", rs.getString("FK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getShort("DEFERRABILITY")); + + assertFalse(rs.next()); } // try getting self-references try (ResultSet rs = @@ -435,15 +397,15 @@ public void testGetCrossReferences() throws SQLException { DEFAULT_CATALOG, DEFAULT_SCHEMA, ALBUMS_TABLE)) { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); } // try getting all cross-references in the database try (ResultSet rs = connection.getMetaData().getCrossReference(null, null, null, null, null, null)) { for (int i = 0; i < 7; i++) { - assertThat(rs.next(), is(true)); + assertTrue(rs.next()); } - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); } } } @@ -524,33 +486,33 @@ public void testGetIndexInfo() throws SQLException { .getIndexInfo(DEFAULT_CATALOG, DEFAULT_SCHEMA, null, false, false)) { for (IndexInfo index : EXPECTED_INDICES) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("TABLE_NAME"), is(equalTo(index.tableName))); - assertThat(rs.getBoolean("NON_UNIQUE"), is(index.nonUnique)); - assertThat(rs.getString("INDEX_QUALIFIER"), is(equalTo(DEFAULT_CATALOG))); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); + assertEquals(index.tableName, rs.getString("TABLE_NAME")); + assertEquals(index.nonUnique, rs.getBoolean("NON_UNIQUE")); + assertEquals(DEFAULT_CATALOG, rs.getString("INDEX_QUALIFIER")); // Foreign key index names are automatically generated. if (!"FOREIGN_KEY".equals(index.indexName) && !"GENERATED".equals(index.indexName)) { - assertThat(rs.getString("INDEX_NAME"), is(equalTo(index.indexName))); + assertEquals(index.indexName, rs.getString("INDEX_NAME")); } if (index.indexName.equals("PRIMARY_KEY")) { - assertThat(rs.getShort("TYPE"), is(equalTo(DatabaseMetaData.tableIndexClustered))); + assertEquals(DatabaseMetaData.tableIndexClustered, rs.getShort("TYPE")); } else { - assertThat(rs.getShort("TYPE"), is(equalTo(DatabaseMetaData.tableIndexHashed))); + assertEquals(DatabaseMetaData.tableIndexHashed, rs.getShort("TYPE")); } - assertThat(rs.getShort("ORDINAL_POSITION"), is(equalTo(index.ordinalPosition))); + assertEquals(index.ordinalPosition, rs.getShort("ORDINAL_POSITION")); if (index.ordinalPosition == 0) { - assertThat(rs.wasNull(), is(true)); + assertTrue(rs.wasNull()); } - assertThat(rs.getString("COLUMN_NAME"), is(equalTo(index.columnName))); - assertThat(rs.getString("ASC_OR_DESC"), is(equalTo(index.ascDesc))); - assertThat(rs.getInt("CARDINALITY"), is(equalTo(-1))); - assertThat(rs.getInt("PAGES"), is(equalTo(-1))); - assertThat(rs.getString("FILTER_CONDITION"), is(nullValue())); + assertEquals(index.columnName, rs.getString("COLUMN_NAME")); + assertEquals(index.ascDesc, rs.getString("ASC_OR_DESC")); + assertEquals(-1, rs.getInt("CARDINALITY")); + assertEquals(-1, rs.getInt("PAGES")); + assertNull(rs.getString("FILTER_CONDITION")); } // all indices found - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); } } } @@ -604,170 +566,170 @@ public void testGetImportedKeys() throws SQLException { } private void assertImportedKeysSingers(ResultSet rs) throws SQLException { - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); } private void assertImportedKeysTableWithRef(ResultSet rs) throws SQLException { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("ColFloat64"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(TABLE_WITH_REF))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("RefFloat"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getString("FK_NAME"), is("Fk_TableWithRef_TableWithAllColumnTypes")); - assertThat(rs.getString("PK_NAME"), is(notNullValue())); // Index name is generated. - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("ColString"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(TABLE_WITH_REF))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("RefString"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 2))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getString("FK_NAME"), is("Fk_TableWithRef_TableWithAllColumnTypes")); - assertThat(rs.getString("PK_NAME"), is(notNullValue())); // Index name is generated. - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(TABLE_WITH_ALL_COLS))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("ColDate"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(TABLE_WITH_REF))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("RefDate"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 3))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getString("FK_NAME"), is("Fk_TableWithRef_TableWithAllColumnTypes")); - assertThat(rs.getString("PK_NAME"), is(notNullValue())); // Index name is generated. - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("PKTABLE_NAME")); + assertEquals("ColFloat64", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(TABLE_WITH_REF, rs.getString("FKTABLE_NAME")); + assertEquals("RefFloat", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("DELETE_RULE")); + assertEquals("Fk_TableWithRef_TableWithAllColumnTypes", rs.getString("FK_NAME")); + assertNotNull(rs.getString("PK_NAME")); // Index name is generated. + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("PKTABLE_NAME")); + assertEquals("ColString", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(TABLE_WITH_REF, rs.getString("FKTABLE_NAME")); + assertEquals("RefString", rs.getString("FKCOLUMN_NAME")); + assertEquals(2, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("DELETE_RULE")); + assertEquals("Fk_TableWithRef_TableWithAllColumnTypes", rs.getString("FK_NAME")); + assertNotNull(rs.getString("PK_NAME")); // Index name is generated. + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(TABLE_WITH_ALL_COLS, rs.getString("PKTABLE_NAME")); + assertEquals("ColDate", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(TABLE_WITH_REF, rs.getString("FKTABLE_NAME")); + assertEquals("RefDate", rs.getString("FKCOLUMN_NAME")); + assertEquals(3, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("DELETE_RULE")); + assertEquals("Fk_TableWithRef_TableWithAllColumnTypes", rs.getString("FK_NAME")); + assertNotNull(rs.getString("PK_NAME")); // Index name is generated. + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertFalse(rs.next()); } private void assertImportedKeysAlbums(ResultSet rs) throws SQLException { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(SINGERS_TABLE))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(ALBUMS_TABLE))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(SINGERS_TABLE, rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(ALBUMS_TABLE, rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getInt("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertFalse(rs.next()); } private void assertImportedKeysConcerts(ResultSet rs) throws SQLException { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(SINGERS_TABLE))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(CONCERTS_TABLE))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getString("FK_NAME"), is("Fk_Concerts_Singer")); - assertThat(rs.getString("PK_NAME"), is(equalTo("PK_Singers"))); - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(SINGERS_TABLE, rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(CONCERTS_TABLE, rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("DELETE_RULE")); + assertEquals("Fk_Concerts_Singer", rs.getString("FK_NAME")); + assertEquals("PK_Singers", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertFalse(rs.next()); } private void assertExportedKeysSingers(ResultSet rs) throws SQLException { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(SINGERS_TABLE))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(ALBUMS_TABLE))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(SINGERS_TABLE))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(CONCERTS_TABLE))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getString("FK_NAME"), is("Fk_Concerts_Singer")); - assertThat(rs.getString("PK_NAME"), is(equalTo("PK_Singers"))); - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(SINGERS_TABLE, rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(ALBUMS_TABLE, rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getInt("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(SINGERS_TABLE, rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(CONCERTS_TABLE, rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("DELETE_RULE")); + assertEquals("Fk_Concerts_Singer", rs.getString("FK_NAME")); + assertEquals("PK_Singers", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertFalse(rs.next()); } private void assertKeysAlbumsSongs(ResultSet rs) throws SQLException { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(ALBUMS_TABLE))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(SONGS_TABLE))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 1))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - - assertThat(rs.next(), is(true)); - assertThat(rs.getString("PKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("PKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("PKTABLE_NAME"), is(equalTo(ALBUMS_TABLE))); - assertThat(rs.getString("PKCOLUMN_NAME"), is(equalTo("AlbumId"))); - assertThat(rs.getString("FKTABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("FKTABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("FKTABLE_NAME"), is(equalTo(SONGS_TABLE))); - assertThat(rs.getString("FKCOLUMN_NAME"), is(equalTo("AlbumId"))); - assertThat(rs.getShort("KEY_SEQ"), is(equalTo((short) 2))); - assertThat(rs.getInt("UPDATE_RULE"), is(equalTo(DatabaseMetaData.importedKeyRestrict))); - assertThat(rs.getInt("DELETE_RULE"), is(equalTo(DatabaseMetaData.importedKeyCascade))); - assertThat(rs.getString("FK_NAME"), is(nullValue())); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.getInt("DEFERRABILITY"), is(equalTo(DatabaseMetaData.importedKeyNotDeferrable))); - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(ALBUMS_TABLE, rs.getString("PKTABLE_NAME")); + assertEquals("SingerId", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(SONGS_TABLE, rs.getString("FKTABLE_NAME")); + assertEquals("SingerId", rs.getString("FKCOLUMN_NAME")); + assertEquals(1, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getInt("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("PKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("PKTABLE_SCHEM")); + assertEquals(ALBUMS_TABLE, rs.getString("PKTABLE_NAME")); + assertEquals("AlbumId", rs.getString("PKCOLUMN_NAME")); + assertEquals(DEFAULT_CATALOG, rs.getString("FKTABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("FKTABLE_SCHEM")); + assertEquals(SONGS_TABLE, rs.getString("FKTABLE_NAME")); + assertEquals("AlbumId", rs.getString("FKCOLUMN_NAME")); + assertEquals(2, rs.getShort("KEY_SEQ")); + assertEquals(DatabaseMetaData.importedKeyRestrict, rs.getInt("UPDATE_RULE")); + assertEquals(DatabaseMetaData.importedKeyCascade, rs.getInt("DELETE_RULE")); + assertNull(rs.getString("FK_NAME")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertEquals(DatabaseMetaData.importedKeyNotDeferrable, rs.getInt("DEFERRABILITY")); + assertFalse(rs.next()); } @Test @@ -775,39 +737,39 @@ public void testGetPrimaryKeys() throws SQLException { try (Connection connection = createConnection(env, database)) { try (ResultSet rs = connection.getMetaData().getPrimaryKeys(DEFAULT_CATALOG, DEFAULT_SCHEMA, SINGERS_TABLE)) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("TABLE_NAME"), is(equalTo(SINGERS_TABLE))); - assertThat(rs.getString("COLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getInt("KEY_SEQ"), is(equalTo(1))); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); + assertEquals(SINGERS_TABLE, rs.getString("TABLE_NAME")); + assertEquals("SingerId", rs.getString("COLUMN_NAME")); + assertEquals(1, rs.getInt("KEY_SEQ")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertFalse(rs.next()); } try (ResultSet rs = connection.getMetaData().getPrimaryKeys(DEFAULT_CATALOG, DEFAULT_SCHEMA, ALBUMS_TABLE)) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("TABLE_NAME"), is(equalTo(ALBUMS_TABLE))); - assertThat(rs.getString("COLUMN_NAME"), is(equalTo("SingerId"))); - assertThat(rs.getInt("KEY_SEQ"), is(equalTo(1))); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_CAT"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("TABLE_NAME"), is(equalTo(ALBUMS_TABLE))); - assertThat(rs.getString("COLUMN_NAME"), is(equalTo("AlbumId"))); - assertThat(rs.getInt("KEY_SEQ"), is(equalTo(2))); - assertThat(rs.getString("PK_NAME"), is(equalTo("PRIMARY_KEY"))); - assertThat(rs.next(), is(false)); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); + assertEquals(ALBUMS_TABLE, rs.getString("TABLE_NAME")); + assertEquals("SingerId", rs.getString("COLUMN_NAME")); + assertEquals(1, rs.getInt("KEY_SEQ")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertTrue(rs.next()); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CAT")); + assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); + assertEquals(ALBUMS_TABLE, rs.getString("TABLE_NAME")); + assertEquals("AlbumId", rs.getString("COLUMN_NAME")); + assertEquals(2, rs.getInt("KEY_SEQ")); + assertEquals("PRIMARY_KEY", rs.getString("PK_NAME")); + assertFalse(rs.next()); } } } @Test public void testGetViews() throws SQLException { - assumeFalse("Emulator does not yet support views", EmulatorSpannerHelper.isUsingEmulator()); + // assumeFalse("Emulator does not yet support views", EmulatorSpannerHelper.isUsingEmulator()); try (Connection connection = createConnection(env, database)) { try (ResultSet rs = connection.getMetaData().getTables("", "", null, new String[] {"VIEW"})) { assertTrue(rs.next()); @@ -824,15 +786,15 @@ public void testGetSchemas() throws SQLException { try (Connection connection = createConnection(env, database)) { assertEquals("", connection.getSchema()); try (ResultSet rs = connection.getMetaData().getSchemas()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo(DEFAULT_SCHEMA))); - assertThat(rs.getString("TABLE_CATALOG"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo("INFORMATION_SCHEMA"))); - assertThat(rs.getString("TABLE_CATALOG"), is(equalTo(DEFAULT_CATALOG))); - assertThat(rs.next(), is(true)); - assertThat(rs.getString("TABLE_SCHEM"), is(equalTo("SPANNER_SYS"))); - assertThat(rs.getString("TABLE_CATALOG"), is(equalTo(DEFAULT_CATALOG))); + assertTrue(rs.next()); + assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CATALOG")); + assertTrue(rs.next()); + assertEquals("INFORMATION_SCHEMA", rs.getString("TABLE_SCHEM")); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CATALOG")); + assertTrue(rs.next()); + assertEquals("SPANNER_SYS", rs.getString("TABLE_SCHEM")); + assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CATALOG")); assertFalse(rs.next()); } } @@ -882,9 +844,6 @@ public void testGetTables() throws SQLException { try (ResultSet rs = connection.getMetaData().getTables(DEFAULT_CATALOG, DEFAULT_SCHEMA, null, null)) { for (Table table : EXPECTED_TABLES) { - if (EmulatorSpannerHelper.isUsingEmulator() && table.name.equals("SingersView")) { - continue; - } assertTrue(rs.next()); assertEquals(DEFAULT_CATALOG, rs.getString("TABLE_CAT")); assertEquals(DEFAULT_SCHEMA, rs.getString("TABLE_SCHEM")); @@ -897,7 +856,7 @@ public void testGetTables() throws SQLException { assertNull(rs.getString("SELF_REFERENCING_COL_NAME")); assertNull(rs.getString("REF_GENERATION")); } - assertThat(rs.next(), is(false)); + assertFalse(rs.next()); } } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcReadWriteAutocommitTest.java b/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcReadWriteAutocommitTest.java index 525ccbbe1..3db849cfd 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcReadWriteAutocommitTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcReadWriteAutocommitTest.java @@ -16,9 +16,8 @@ package com.google.cloud.spanner.jdbc.it; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import com.google.cloud.spanner.Database; import com.google.cloud.spanner.Dialect; @@ -101,8 +100,8 @@ public void test02_WriteMutation() throws Exception { "SHOW VARIABLE %sCOMMIT_TIMESTAMP", getDialect() == Dialect.POSTGRESQL ? "SPANNER." : "")); try (java.sql.ResultSet rs = statement.getResultSet()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getTimestamp(1), is(notNullValue())); + assertTrue(rs.next()); + assertNotNull(rs.getTimestamp(1)); } } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcScriptTest.java b/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcScriptTest.java index 8d8c0ffa0..9aeb5c730 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcScriptTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/it/ITJdbcScriptTest.java @@ -16,10 +16,9 @@ package com.google.cloud.spanner.jdbc.it; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import static org.junit.Assume.assumeFalse; import com.google.cloud.spanner.Database; @@ -313,8 +312,8 @@ public void test11_TestStatementTimeout() throws Exception { statement.setQueryTimeout(1); statement.execute("SHOW VARIABLE STATEMENT_TIMEOUT"); try (ResultSet rs = statement.getResultSet()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("STATEMENT_TIMEOUT"), is(nullValue())); + assertTrue(rs.next()); + assertNull(rs.getString("STATEMENT_TIMEOUT")); } // Now set a STATEMENT_TIMEOUT on the connection that is different from the query timeout of @@ -323,8 +322,8 @@ public void test11_TestStatementTimeout() throws Exception { statement.execute("SET STATEMENT_TIMEOUT='100ms'"); statement.execute("SHOW VARIABLE STATEMENT_TIMEOUT"); try (ResultSet rs = statement.getResultSet()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("STATEMENT_TIMEOUT"), is(equalTo("100ms"))); + assertTrue(rs.next()); + assertEquals("100ms", rs.getString("STATEMENT_TIMEOUT")); } // Remove the statement timeout again, and verify that SHOW STATEMENT_TIMEOUT once again @@ -332,8 +331,8 @@ public void test11_TestStatementTimeout() throws Exception { statement.execute("SET STATEMENT_TIMEOUT=NULL"); statement.execute("SHOW VARIABLE STATEMENT_TIMEOUT"); try (ResultSet rs = statement.getResultSet()) { - assertThat(rs.next(), is(true)); - assertThat(rs.getString("STATEMENT_TIMEOUT"), is(nullValue())); + assertTrue(rs.next()); + assertNull(rs.getString("STATEMENT_TIMEOUT")); } } } From 1583b24124be4a6c990b8d94aee559b9fe4c71d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Knut=20Olav=20L=C3=B8ite?= Date: Tue, 6 Aug 2024 17:45:38 +0200 Subject: [PATCH 14/20] test: verify that executeUpdate can be used for DDL (#1694) The JDBC driver should now support executing DDL using the executeUpdate methods of java.sql.Statement and java.sql.PreparedStatement. Closes #1150 --- .../cloud/spanner/jdbc/DdlMockServerTest.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/src/test/java/com/google/cloud/spanner/jdbc/DdlMockServerTest.java b/src/test/java/com/google/cloud/spanner/jdbc/DdlMockServerTest.java index 76cac4fa6..75f9d9efc 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/DdlMockServerTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/DdlMockServerTest.java @@ -31,6 +31,7 @@ import com.google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata; import java.sql.Connection; import java.sql.DriverManager; +import java.sql.PreparedStatement; import java.sql.SQLException; import org.junit.Test; import org.junit.runner.RunWith; @@ -98,4 +99,45 @@ public void testDdlInAutoCommitIsFalse_failsWithActiveTransaction() throws SQLEx assertEquals(Code.FAILED_PRECONDITION, jdbcSqlException.getCode()); } } + + @Test + public void testDdlUsingStatementAndExecuteUpdate() throws SQLException { + for (boolean autoCommit : new boolean[] {true, false}) { + mockDatabaseAdmin.addResponse( + Operation.newBuilder() + .setDone(true) + .setResponse(Any.pack(Empty.getDefaultInstance())) + .setMetadata(Any.pack(UpdateDatabaseDdlMetadata.getDefaultInstance())) + .build()); + + try (Connection connection = createConnection(autoCommit)) { + try (java.sql.Statement statement = connection.createStatement()) { + assertEquals(0, statement.executeUpdate("create table foo (id int64) primary key (id)")); + } + } + assertEquals(1, mockDatabaseAdmin.getRequests().size()); + mockDatabaseAdmin.getRequests().clear(); + } + } + + @Test + public void testDdlUsingPreparedStatementAndExecuteUpdate() throws SQLException { + for (boolean autoCommit : new boolean[] {true, false}) { + mockDatabaseAdmin.addResponse( + Operation.newBuilder() + .setDone(true) + .setResponse(Any.pack(Empty.getDefaultInstance())) + .setMetadata(Any.pack(UpdateDatabaseDdlMetadata.getDefaultInstance())) + .build()); + + try (Connection connection = createConnection(autoCommit)) { + try (PreparedStatement preparedStatement = + connection.prepareStatement("create table foo (id int64) primary key (id)")) { + assertEquals(0, preparedStatement.executeUpdate()); + } + } + assertEquals(1, mockDatabaseAdmin.getRequests().size()); + mockDatabaseAdmin.getRequests().clear(); + } + } } From c6a54f7a3045fc711fcad8d16294c67aa8eb8810 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 6 Aug 2024 19:00:56 +0200 Subject: [PATCH 15/20] deps: update dependency com.google.cloud:google-cloud-trace to v2.47.0 (#1696) --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 59adb9d33..98d60ce37 100644 --- a/pom.xml +++ b/pom.xml @@ -225,7 +225,7 @@ com.google.cloud google-cloud-trace - 2.46.0 + 2.47.0 test From 148c655a8bd1309250b5158d0f20a167e89bd9fe Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 6 Aug 2024 19:01:19 +0200 Subject: [PATCH 16/20] deps: update dependency com.google.api.grpc:proto-google-cloud-trace-v1 to v2.47.0 (#1695) --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 98d60ce37..08f73f73e 100644 --- a/pom.xml +++ b/pom.xml @@ -231,7 +231,7 @@ com.google.api.grpc proto-google-cloud-trace-v1 - 2.46.0 + 2.47.0 test From 08011a520a2fb14d06614da5e2c7b9ae47d6c6f1 Mon Sep 17 00:00:00 2001 From: Mend Renovate Date: Tue, 6 Aug 2024 19:47:18 +0200 Subject: [PATCH 17/20] deps: update dependency com.google.cloud:sdk-platform-java-config to v3.33.0 (#1693) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * deps: update dependency com.google.cloud:sdk-platform-java-config to v3.33.0 * deps: add incubator dep needed for test * deps: work around unnecessary dependency * chore: run formatter --------- Co-authored-by: Knut Olav Løite --- .github/workflows/unmanaged_dependency_check.yaml | 2 +- .kokoro/presubmit/graalvm-native-17.cfg | 2 +- .kokoro/presubmit/graalvm-native.cfg | 2 +- pom.xml | 9 ++++++++- samples/snippets/pom.xml | 2 +- .../cloud/spanner/jdbc/it/ITOpenTelemetryTest.java | 8 +++++--- 6 files changed, 17 insertions(+), 8 deletions(-) diff --git a/.github/workflows/unmanaged_dependency_check.yaml b/.github/workflows/unmanaged_dependency_check.yaml index 8eb9dfbd6..09f954387 100644 --- a/.github/workflows/unmanaged_dependency_check.yaml +++ b/.github/workflows/unmanaged_dependency_check.yaml @@ -14,6 +14,6 @@ jobs: shell: bash run: .kokoro/build.sh - name: Unmanaged dependency check - uses: googleapis/sdk-platform-java/java-shared-dependencies/unmanaged-dependency-check@google-cloud-shared-dependencies/v3.32.0 + uses: googleapis/sdk-platform-java/java-shared-dependencies/unmanaged-dependency-check@google-cloud-shared-dependencies/v3.33.0 with: bom-path: pom.xml diff --git a/.kokoro/presubmit/graalvm-native-17.cfg b/.kokoro/presubmit/graalvm-native-17.cfg index 7d5ab3a25..7008a7215 100644 --- a/.kokoro/presubmit/graalvm-native-17.cfg +++ b/.kokoro/presubmit/graalvm-native-17.cfg @@ -3,7 +3,7 @@ # Configure the docker image for kokoro-trampoline. env_vars: { key: "TRAMPOLINE_IMAGE" - value: "gcr.io/cloud-devrel-public-resources/graalvm_sdk_platform_b:3.32.0" + value: "gcr.io/cloud-devrel-public-resources/graalvm_sdk_platform_b:3.33.0" } env_vars: { diff --git a/.kokoro/presubmit/graalvm-native.cfg b/.kokoro/presubmit/graalvm-native.cfg index 519c2e3ce..931f9bb00 100644 --- a/.kokoro/presubmit/graalvm-native.cfg +++ b/.kokoro/presubmit/graalvm-native.cfg @@ -3,7 +3,7 @@ # Configure the docker image for kokoro-trampoline. env_vars: { key: "TRAMPOLINE_IMAGE" - value: "gcr.io/cloud-devrel-public-resources/graalvm_sdk_platform_a:3.32.0" + value: "gcr.io/cloud-devrel-public-resources/graalvm_sdk_platform_a:3.33.0" } env_vars: { diff --git a/pom.xml b/pom.xml index 08f73f73e..d510d8133 100644 --- a/pom.xml +++ b/pom.xml @@ -14,7 +14,7 @@ com.google.cloud sdk-platform-java-config - 3.32.0 + 3.33.0 @@ -201,6 +201,13 @@ + + + io.opentelemetry + opentelemetry-api-incubator + 1.40.0-alpha + test + io.opentelemetry opentelemetry-sdk diff --git a/samples/snippets/pom.xml b/samples/snippets/pom.xml index 0c3b12de9..ee6deda8b 100644 --- a/samples/snippets/pom.xml +++ b/samples/snippets/pom.xml @@ -9,7 +9,7 @@ com.google.cloud sdk-platform-java-config - 3.32.0 + 3.33.0 diff --git a/src/test/java/com/google/cloud/spanner/jdbc/it/ITOpenTelemetryTest.java b/src/test/java/com/google/cloud/spanner/jdbc/it/ITOpenTelemetryTest.java index 19fb1146e..bbbbaf344 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/it/ITOpenTelemetryTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/it/ITOpenTelemetryTest.java @@ -38,6 +38,7 @@ import com.google.common.collect.Iterables; import com.google.devtools.cloudtrace.v1.ListTracesRequest; import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.incubator.trace.ExtendedTracer; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.resources.Resource; import io.opentelemetry.sdk.trace.SdkTracerProvider; @@ -79,7 +80,7 @@ public class ITOpenTelemetryTest extends ITAbstractJdbcTest { private Database database; @BeforeClass - public static void setupOpenTelemetry() throws IOException { + public static void setupOpenTelemetry() { assumeFalse("This test requires credentials", EmulatorSpannerHelper.isUsingEmulator()); SpannerOptions options = env.getTestHelper().getOptions(); @@ -103,6 +104,9 @@ public static void setupOpenTelemetry() throws IOException { .addSpanProcessor(BatchSpanProcessor.builder(traceExporter).build()) .build()) .build(); + // TODO: Remove when the bug in OpenTelemetry that has SdkTracer implement ExtendedTracer, + // which is only available in the incubator project. + ExtendedTracer ignore = (ExtendedTracer) openTelemetry.getTracer("foo"); } @AfterClass @@ -245,8 +249,6 @@ private void assertTrace(String sql) throws IOException, InterruptedException { Thread.sleep(5000L); boolean foundTrace = false; for (int attempts = 0; attempts < 20; attempts++) { - // Ignore deprecation for now, as there is no alternative offered (yet?). - //noinspection deprecation ListTracesPagedResponse response = client.listTraces( ListTracesRequest.newBuilder() From 828aff6f7015b5f91ebbc2ad54aeeecf5515a9bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Knut=20Olav=20L=C3=B8ite?= Date: Tue, 6 Aug 2024 19:48:09 +0200 Subject: [PATCH 18/20] fix: support getShort for DATA_TYPE in TypeInfo (#1691) * fix: support getShort for DATA_TYPE in TypeInfo The ResultSet that is returned by DatabaseMetadata#getTypeInfo has a column at index 2 with the name DATA_TYPE. This field should contain one of the java.sql.Types constants, or a vendor-specific type code. The JDBC specification states that this column should be a `short` (although the constants in java.sql.Types are of type `int`). Cloud Spanner (at the time of writing) does not support any int16 fields. The type code is therefore returned as an int64. The codes that are used for vendor-specific types by Spanner exceed the max value of a `short`, and therefore resulted in an OUT_OF_RANGE exception if you tried to call `ResultSet#getShort(int)` on this column for any of the Spanner-specific types (e.g. JSON). This change fixes that by adding an additional vendor type code for these types that does fit in a `short`. This value is returned when `getShort(int)` is called on the ResultSet. Fixes #1688 * chore: cleanup --- .../spanner/jdbc/JdbcDatabaseMetaData.java | 5 +- .../spanner/jdbc/JdbcParameterStore.java | 38 ++++++++++++-- .../cloud/spanner/jdbc/JdbcResultSet.java | 28 +++++++++- .../google/cloud/spanner/jdbc/JsonType.java | 6 +++ .../cloud/spanner/jdbc/PgJsonbType.java | 6 +++ .../cloud/spanner/jdbc/ProtoEnumType.java | 6 +++ .../cloud/spanner/jdbc/ProtoMessageType.java | 6 +++ .../jdbc/JdbcDatabaseMetaDataTest.java | 29 ++++++++++- .../spanner/jdbc/JdbcParameterStoreTest.java | 51 ++++++++++++++++--- 9 files changed, 160 insertions(+), 15 deletions(-) diff --git a/src/main/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaData.java b/src/main/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaData.java index 025b26570..7bafb2f37 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaData.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaData.java @@ -26,6 +26,7 @@ import com.google.cloud.spanner.Type.StructField; import com.google.cloud.spanner.connection.Connection.InternalMetadataQuery; import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; @@ -1284,7 +1285,9 @@ public ResultSet getTypeInfo() { .set("NUM_PREC_RADIX") .to(10) .build(), - getJsonType(connection.getDialect())))); + getJsonType(connection.getDialect()))), + // Allow column 2 to be cast to short without any range checks. + ImmutableSet.of(2)); } private Struct getJsonType(Dialect dialect) { diff --git a/src/main/java/com/google/cloud/spanner/jdbc/JdbcParameterStore.java b/src/main/java/com/google/cloud/spanner/jdbc/JdbcParameterStore.java index accb6323f..47d096261 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/JdbcParameterStore.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/JdbcParameterStore.java @@ -284,9 +284,13 @@ private boolean isTypeSupported(int sqlType) { case Types.NUMERIC: case Types.DECIMAL: case JsonType.VENDOR_TYPE_NUMBER: + case JsonType.SHORT_VENDOR_TYPE_NUMBER: case PgJsonbType.VENDOR_TYPE_NUMBER: + case PgJsonbType.SHORT_VENDOR_TYPE_NUMBER: case ProtoMessageType.VENDOR_TYPE_NUMBER: + case ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER: case ProtoEnumType.VENDOR_TYPE_NUMBER: + case ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER: return true; } return false; @@ -348,19 +352,23 @@ private boolean isValidTypeAndValue(Object value, int sqlType) { case Types.NCLOB: return value instanceof NClob || value instanceof Reader; case JsonType.VENDOR_TYPE_NUMBER: + case JsonType.SHORT_VENDOR_TYPE_NUMBER: return value instanceof String || value instanceof InputStream || value instanceof Reader || (value instanceof Value && ((Value) value).getType().getCode() == Type.Code.JSON); case PgJsonbType.VENDOR_TYPE_NUMBER: + case PgJsonbType.SHORT_VENDOR_TYPE_NUMBER: return value instanceof String || value instanceof InputStream || value instanceof Reader || (value instanceof Value && ((Value) value).getType().getCode() == Type.Code.PG_JSONB); case ProtoMessageType.VENDOR_TYPE_NUMBER: + case ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER: return value instanceof AbstractMessage || value instanceof byte[]; case ProtoEnumType.VENDOR_TYPE_NUMBER: + case ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER: return value instanceof ProtocolMessageEnum || value instanceof Number; } return false; @@ -449,7 +457,12 @@ private Builder setSingleValue(ValueBinder binder, Object value, Intege /** Set a JDBC parameter value on a Spanner {@link Statement} with a known SQL type. */ private Builder setParamWithKnownType(ValueBinder binder, Object value, Integer sqlType) throws SQLException { - switch (sqlType) { + if (sqlType == null) { + return null; + } + int type = sqlType; + + switch (type) { case Types.BIT: case Types.BOOLEAN: if (value instanceof Boolean) { @@ -522,7 +535,9 @@ private Builder setParamWithKnownType(ValueBinder binder, Object value, } return binder.to(stringValue); case JsonType.VENDOR_TYPE_NUMBER: + case JsonType.SHORT_VENDOR_TYPE_NUMBER: case PgJsonbType.VENDOR_TYPE_NUMBER: + case PgJsonbType.SHORT_VENDOR_TYPE_NUMBER: String jsonValue; if (value instanceof String) { jsonValue = (String) value; @@ -534,7 +549,8 @@ private Builder setParamWithKnownType(ValueBinder binder, Object value, throw JdbcSqlExceptionFactory.of( value + " is not a valid JSON value", Code.INVALID_ARGUMENT); } - if (sqlType == PgJsonbType.VENDOR_TYPE_NUMBER) { + if (type == PgJsonbType.VENDOR_TYPE_NUMBER + || type == PgJsonbType.SHORT_VENDOR_TYPE_NUMBER) { return binder.to(Value.pgJsonb(jsonValue)); } return binder.to(Value.json(jsonValue)); @@ -631,6 +647,7 @@ private Builder setParamWithKnownType(ValueBinder binder, Object value, } throw JdbcSqlExceptionFactory.of(value + " is not a valid clob", Code.INVALID_ARGUMENT); case ProtoMessageType.VENDOR_TYPE_NUMBER: + case ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER: if (value instanceof AbstractMessage) { return binder.to((AbstractMessage) value); } else if (value instanceof byte[]) { @@ -640,6 +657,7 @@ private Builder setParamWithKnownType(ValueBinder binder, Object value, value + " is not a valid PROTO value", Code.INVALID_ARGUMENT); } case ProtoEnumType.VENDOR_TYPE_NUMBER: + case ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER: if (value instanceof ProtocolMessageEnum) { return binder.to((ProtocolMessageEnum) value); } else if (value instanceof Number) { @@ -809,8 +827,10 @@ private Builder setArrayValue(ValueBinder binder, int type, Object valu case Types.NCLOB: return binder.toStringArray(null); case JsonType.VENDOR_TYPE_NUMBER: + case JsonType.SHORT_VENDOR_TYPE_NUMBER: return binder.toJsonArray(null); case PgJsonbType.VENDOR_TYPE_NUMBER: + case PgJsonbType.SHORT_VENDOR_TYPE_NUMBER: return binder.toPgJsonbArray(null); case Types.DATE: return binder.toDateArray(null); @@ -825,7 +845,9 @@ private Builder setArrayValue(ValueBinder binder, int type, Object valu case Types.BLOB: return binder.toBytesArray(null); case ProtoMessageType.VENDOR_TYPE_NUMBER: + case ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER: case ProtoEnumType.VENDOR_TYPE_NUMBER: + case ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER: return binder.to( Value.untyped( com.google.protobuf.Value.newBuilder() @@ -886,9 +908,10 @@ private Builder setArrayValue(ValueBinder binder, int type, Object valu } else if (Timestamp[].class.isAssignableFrom(value.getClass())) { return binder.toTimestampArray(JdbcTypeConverter.toGoogleTimestamps((Timestamp[]) value)); } else if (String[].class.isAssignableFrom(value.getClass())) { - if (type == JsonType.VENDOR_TYPE_NUMBER) { + if (type == JsonType.VENDOR_TYPE_NUMBER || type == JsonType.SHORT_VENDOR_TYPE_NUMBER) { return binder.toJsonArray(Arrays.asList((String[]) value)); - } else if (type == PgJsonbType.VENDOR_TYPE_NUMBER) { + } else if (type == PgJsonbType.VENDOR_TYPE_NUMBER + || type == PgJsonbType.SHORT_VENDOR_TYPE_NUMBER) { return binder.toPgJsonbArray(Arrays.asList((String[]) value)); } else { return binder.toStringArray(Arrays.asList((String[]) value)); @@ -992,11 +1015,13 @@ private Builder setNullValue(ValueBinder binder, Integer sqlType) { Value.untyped( com.google.protobuf.Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build())); } - switch (sqlType) { + int type = sqlType; + switch (type) { case Types.BIGINT: return binder.to((Long) null); case Types.BINARY: case ProtoMessageType.VENDOR_TYPE_NUMBER: + case ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER: return binder.to((ByteArray) null); case Types.BLOB: return binder.to((ByteArray) null); @@ -1021,6 +1046,7 @@ private Builder setNullValue(ValueBinder binder, Integer sqlType) { return binder.to((Double) null); case Types.INTEGER: case ProtoEnumType.VENDOR_TYPE_NUMBER: + case ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER: return binder.to((Long) null); case Types.LONGNVARCHAR: return binder.to((String) null); @@ -1052,8 +1078,10 @@ private Builder setNullValue(ValueBinder binder, Integer sqlType) { case Types.VARCHAR: return binder.to((String) null); case JsonType.VENDOR_TYPE_NUMBER: + case JsonType.SHORT_VENDOR_TYPE_NUMBER: return binder.to(Value.json(null)); case PgJsonbType.VENDOR_TYPE_NUMBER: + case PgJsonbType.SHORT_VENDOR_TYPE_NUMBER: return binder.to(Value.pgJsonb(null)); default: return binder.to( diff --git a/src/main/java/com/google/cloud/spanner/jdbc/JdbcResultSet.java b/src/main/java/com/google/cloud/spanner/jdbc/JdbcResultSet.java index 054c1ed00..00df25116 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/JdbcResultSet.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/JdbcResultSet.java @@ -26,6 +26,7 @@ import com.google.cloud.spanner.connection.PartitionedQueryResultSet; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; import java.io.ByteArrayInputStream; import java.io.InputStream; import java.io.Reader; @@ -57,8 +58,16 @@ class JdbcResultSet extends AbstractJdbcResultSet { static JdbcResultSet of(com.google.cloud.spanner.ResultSet resultSet) { - Preconditions.checkNotNull(resultSet); - return new JdbcResultSet(null, resultSet); + return of(resultSet, ImmutableSet.of()); + } + + static JdbcResultSet of( + com.google.cloud.spanner.ResultSet resultSet, + ImmutableSet columnsAllowedUncheckedLongCastToShort) { + return new JdbcResultSet( + null, + Preconditions.checkNotNull(resultSet), + Preconditions.checkNotNull(columnsAllowedUncheckedLongCastToShort)); } static JdbcResultSet of(Statement statement, com.google.cloud.spanner.ResultSet resultSet) { @@ -129,10 +138,19 @@ public Struct next() { private boolean nextCalledForMetaData = false; private boolean nextCalledForMetaDataResult = false; private long currentRow = 0L; + private final ImmutableSet columnsAllowedUncheckedLongCastToShort; JdbcResultSet(Statement statement, com.google.cloud.spanner.ResultSet spanner) { + this(statement, spanner, ImmutableSet.of()); + } + + JdbcResultSet( + Statement statement, + com.google.cloud.spanner.ResultSet spanner, + ImmutableSet columnsAllowedUncheckedLongCastToShort) { super(spanner); this.statement = statement; + this.columnsAllowedUncheckedLongCastToShort = columnsAllowedUncheckedLongCastToShort; } void checkClosedAndValidRow() throws SQLException { @@ -327,6 +345,12 @@ public short getShort(int columnIndex) throws SQLException { : checkedCastToShort(Double.valueOf(spanner.getDouble(spannerIndex)).longValue()); case INT64: case ENUM: + if (this.columnsAllowedUncheckedLongCastToShort.contains(columnIndex)) { + // This is used to allow frameworks that call getShort(int) on the ResultSet that is + // returned by DatabaseMetadata#getTypeInfo() to get the type code as a short, even when + // the value is out of range for a short. + return isNull ? 0 : (short) spanner.getLong(spannerIndex); + } return isNull ? 0 : checkedCastToShort(spanner.getLong(spannerIndex)); case NUMERIC: return isNull ? 0 : checkedCastToShort(spanner.getBigDecimal(spannerIndex)); diff --git a/src/main/java/com/google/cloud/spanner/jdbc/JsonType.java b/src/main/java/com/google/cloud/spanner/jdbc/JsonType.java index 44af26b6e..3e69adea4 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/JsonType.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/JsonType.java @@ -17,6 +17,7 @@ package com.google.cloud.spanner.jdbc; import com.google.spanner.v1.TypeCode; +import java.sql.DatabaseMetaData; import java.sql.PreparedStatement; import java.sql.SQLType; @@ -31,6 +32,11 @@ public class JsonType implements SQLType { * conflicts with the type numbers in java.sql.Types. */ public static final int VENDOR_TYPE_NUMBER = 100_000 + TypeCode.JSON_VALUE; + /** + * Define a short type number as well, as this is what is expected to be returned in {@link + * DatabaseMetaData#getTypeInfo()}. + */ + public static final short SHORT_VENDOR_TYPE_NUMBER = (short) VENDOR_TYPE_NUMBER; private JsonType() {} diff --git a/src/main/java/com/google/cloud/spanner/jdbc/PgJsonbType.java b/src/main/java/com/google/cloud/spanner/jdbc/PgJsonbType.java index 8627d3413..b0a819b0d 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/PgJsonbType.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/PgJsonbType.java @@ -17,6 +17,7 @@ package com.google.cloud.spanner.jdbc; import com.google.spanner.v1.TypeCode; +import java.sql.DatabaseMetaData; import java.sql.SQLType; public class PgJsonbType implements SQLType { @@ -27,6 +28,11 @@ public class PgJsonbType implements SQLType { * the range starting at 100,000 (see {@link JsonType}). */ public static final int VENDOR_TYPE_NUMBER = 200_000 + TypeCode.JSON_VALUE; + /** + * Define a short type number as well, as this is what is expected to be returned in {@link + * DatabaseMetaData#getTypeInfo()}. + */ + public static final short SHORT_VENDOR_TYPE_NUMBER = (short) VENDOR_TYPE_NUMBER; private PgJsonbType() {} diff --git a/src/main/java/com/google/cloud/spanner/jdbc/ProtoEnumType.java b/src/main/java/com/google/cloud/spanner/jdbc/ProtoEnumType.java index 478d082e9..953fb73b3 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/ProtoEnumType.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/ProtoEnumType.java @@ -17,6 +17,7 @@ package com.google.cloud.spanner.jdbc; import com.google.spanner.v1.TypeCode; +import java.sql.DatabaseMetaData; import java.sql.PreparedStatement; import java.sql.SQLType; @@ -31,6 +32,11 @@ public class ProtoEnumType implements SQLType { * conflicts with the type numbers in java.sql.Types. */ public static final int VENDOR_TYPE_NUMBER = 100_000 + TypeCode.ENUM_VALUE; + /** + * Define a short type number as well, as this is what is expected to be returned in {@link + * DatabaseMetaData#getTypeInfo()}. + */ + public static final short SHORT_VENDOR_TYPE_NUMBER = (short) VENDOR_TYPE_NUMBER; private ProtoEnumType() {} diff --git a/src/main/java/com/google/cloud/spanner/jdbc/ProtoMessageType.java b/src/main/java/com/google/cloud/spanner/jdbc/ProtoMessageType.java index 5a813d66d..2a7f6f705 100644 --- a/src/main/java/com/google/cloud/spanner/jdbc/ProtoMessageType.java +++ b/src/main/java/com/google/cloud/spanner/jdbc/ProtoMessageType.java @@ -17,6 +17,7 @@ package com.google.cloud.spanner.jdbc; import com.google.spanner.v1.TypeCode; +import java.sql.DatabaseMetaData; import java.sql.PreparedStatement; import java.sql.SQLType; @@ -31,6 +32,11 @@ public class ProtoMessageType implements SQLType { * conflicts with the type numbers in java.sql.Types. */ public static final int VENDOR_TYPE_NUMBER = 100_000 + TypeCode.PROTO_VALUE; + /** + * Define a short type number as well, as this is what is expected to be returned in {@link + * DatabaseMetaData#getTypeInfo()}. + */ + public static final short SHORT_VENDOR_TYPE_NUMBER = (short) VENDOR_TYPE_NUMBER; private ProtoMessageType() {} diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java index 3e94a4ceb..64499f40a 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcDatabaseMetaDataTest.java @@ -475,24 +475,51 @@ public void testGetTypeInfo() throws SQLException { try (ResultSet rs = meta.getTypeInfo()) { assertTrue(rs.next()); assertEquals("STRING", rs.getString("TYPE_NAME")); + assertEquals(Types.NVARCHAR, rs.getInt("DATA_TYPE")); + assertEquals(Types.NVARCHAR, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("INT64", rs.getString("TYPE_NAME")); + assertEquals(Types.BIGINT, rs.getInt("DATA_TYPE")); + assertEquals(Types.BIGINT, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("BYTES", rs.getString("TYPE_NAME")); + assertEquals(Types.BINARY, rs.getInt("DATA_TYPE")); + assertEquals(Types.BINARY, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("FLOAT32", rs.getString("TYPE_NAME")); + assertEquals(Types.REAL, rs.getInt("DATA_TYPE")); + assertEquals(Types.REAL, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("FLOAT64", rs.getString("TYPE_NAME")); + assertEquals(Types.DOUBLE, rs.getInt("DATA_TYPE")); + assertEquals(Types.DOUBLE, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("BOOL", rs.getString("TYPE_NAME")); + assertEquals(Types.BOOLEAN, rs.getInt("DATA_TYPE")); + assertEquals(Types.BOOLEAN, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("DATE", rs.getString("TYPE_NAME")); + assertEquals(Types.DATE, rs.getInt("DATA_TYPE")); + assertEquals(Types.DATE, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("TIMESTAMP", rs.getString("TYPE_NAME")); + assertEquals(Types.TIMESTAMP, rs.getInt("DATA_TYPE")); + assertEquals(Types.TIMESTAMP, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); assertEquals("NUMERIC", rs.getString("TYPE_NAME")); + assertEquals(Types.NUMERIC, rs.getInt("DATA_TYPE")); + assertEquals(Types.NUMERIC, rs.getShort("DATA_TYPE")); assertTrue(rs.next()); - assertEquals(dialect == Dialect.POSTGRESQL ? "JSONB" : "JSON", rs.getString("TYPE_NAME")); + if (dialect == Dialect.POSTGRESQL) { + assertEquals("JSONB", rs.getString("TYPE_NAME")); + assertEquals(PgJsonbType.VENDOR_TYPE_NUMBER, rs.getInt("DATA_TYPE")); + assertEquals(PgJsonbType.SHORT_VENDOR_TYPE_NUMBER, rs.getShort("DATA_TYPE")); + } else { + assertEquals("JSON", rs.getString("TYPE_NAME")); + assertEquals(JsonType.VENDOR_TYPE_NUMBER, rs.getInt("DATA_TYPE")); + assertEquals(JsonType.SHORT_VENDOR_TYPE_NUMBER, rs.getShort("DATA_TYPE")); + } + assertFalse(rs.next()); ResultSetMetaData rsmd = rs.getMetaData(); assertEquals(18, rsmd.getColumnCount()); diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcParameterStoreTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcParameterStoreTest.java index eb8237c0b..d77c932c1 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcParameterStoreTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcParameterStoreTest.java @@ -225,6 +225,10 @@ public void testSetParameterWithType() throws SQLException, IOException { assertEquals(jsonString, params.getParameter(1)); verifyParameter(params, Value.json(jsonString)); + params.setParameter(1, jsonString, (int) JsonType.SHORT_VENDOR_TYPE_NUMBER); + assertEquals(jsonString, params.getParameter(1)); + verifyParameter(params, Value.json(jsonString)); + params.setParameter(1, jsonString, JsonType.INSTANCE); assertEquals(jsonString, params.getParameter(1)); verifyParameter(params, Value.json(jsonString)); @@ -233,6 +237,10 @@ public void testSetParameterWithType() throws SQLException, IOException { assertEquals(jsonString, params.getParameter(1)); verifyParameter(params, Value.pgJsonb(jsonString)); + params.setParameter(1, jsonString, (int) PgJsonbType.SHORT_VENDOR_TYPE_NUMBER); + assertEquals(jsonString, params.getParameter(1)); + verifyParameter(params, Value.pgJsonb(jsonString)); + params.setParameter(1, jsonString, PgJsonbType.INSTANCE); assertEquals(jsonString, params.getParameter(1)); verifyParameter(params, Value.pgJsonb(jsonString)); @@ -250,6 +258,10 @@ public void testSetParameterWithType() throws SQLException, IOException { assertEquals(singerInfo, params.getParameter(1)); verifyParameter(params, Value.protoMessage(singerInfo)); + params.setParameter(1, singerInfo, (int) ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER); + assertEquals(singerInfo, params.getParameter(1)); + verifyParameter(params, Value.protoMessage(singerInfo)); + params.setParameter(1, singerInfo, ProtoMessageType.INSTANCE); assertEquals(singerInfo, params.getParameter(1)); verifyParameter(params, Value.protoMessage(singerInfo)); @@ -259,6 +271,11 @@ public void testSetParameterWithType() throws SQLException, IOException { assertArrayEquals(singerInfo.toByteArray(), (byte[]) params.getParameter(1)); verifyParameter(params, Value.bytes(ByteArray.copyFrom(singerInfo.toByteArray()))); + params.setParameter( + 1, singerInfo.toByteArray(), (int) ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER); + assertArrayEquals(singerInfo.toByteArray(), (byte[]) params.getParameter(1)); + verifyParameter(params, Value.bytes(ByteArray.copyFrom(singerInfo.toByteArray()))); + params.setParameter(1, singerInfo, Types.BINARY); assertEquals(singerInfo, params.getParameter(1)); verifyParameter(params, Value.protoMessage(singerInfo)); @@ -267,6 +284,10 @@ public void testSetParameterWithType() throws SQLException, IOException { assertEquals(Genre.ROCK, params.getParameter(1)); verifyParameter(params, Value.protoEnum(Genre.ROCK)); + params.setParameter(1, Genre.ROCK, (int) ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER); + assertEquals(Genre.ROCK, params.getParameter(1)); + verifyParameter(params, Value.protoEnum(Genre.ROCK)); + params.setParameter(1, Genre.ROCK, ProtoEnumType.INSTANCE); assertEquals(Genre.ROCK, params.getParameter(1)); verifyParameter(params, Value.protoEnum(Genre.ROCK)); @@ -276,6 +297,10 @@ public void testSetParameterWithType() throws SQLException, IOException { assertEquals(Genre.ROCK.getNumber(), params.getParameter(1)); verifyParameter(params, Value.int64(Genre.ROCK.getNumber())); + params.setParameter(1, Genre.ROCK.getNumber(), (int) ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER); + assertEquals(Genre.ROCK.getNumber(), params.getParameter(1)); + verifyParameter(params, Value.int64(Genre.ROCK.getNumber())); + params.setParameter(1, Genre.ROCK, Types.INTEGER); assertEquals(Genre.ROCK, params.getParameter(1)); verifyParameter(params, Value.protoEnum(Genre.ROCK)); @@ -287,7 +312,8 @@ public void testSetParameterWithType() throws SQLException, IOException { Types.SMALLINT, Types.INTEGER, Types.BIGINT, - ProtoEnumType.VENDOR_TYPE_NUMBER + ProtoEnumType.VENDOR_TYPE_NUMBER, + ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER }) { params.setParameter(1, (byte) 1, type); assertEquals(1, ((Byte) params.getParameter(1)).byteValue()); @@ -397,7 +423,11 @@ public void testSetParameterWithType() throws SQLException, IOException { // types that should lead to bytes (except BLOB which is handled separately) for (int type : new int[] { - Types.BINARY, Types.VARBINARY, Types.LONGVARBINARY, ProtoMessageType.VENDOR_TYPE_NUMBER + Types.BINARY, + Types.VARBINARY, + Types.LONGVARBINARY, + ProtoMessageType.VENDOR_TYPE_NUMBER, + ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER }) { params.setParameter(1, new byte[] {1, 2, 3}, type); assertArrayEquals(new byte[] {1, 2, 3}, (byte[]) params.getParameter(1)); @@ -512,7 +542,8 @@ public void testSetInvalidParameterWithType() throws SQLException, IOException { Types.SMALLINT, Types.INTEGER, Types.BIGINT, - ProtoEnumType.VENDOR_TYPE_NUMBER + ProtoEnumType.VENDOR_TYPE_NUMBER, + ProtoEnumType.SHORT_VENDOR_TYPE_NUMBER }) { assertInvalidParameter(params, "1", type); assertInvalidParameter(params, new Object(), type); @@ -557,7 +588,11 @@ public void testSetInvalidParameterWithType() throws SQLException, IOException { // types that should lead to bytes (except BLOB which is handled separately) for (int type : new int[] { - Types.BINARY, Types.VARBINARY, Types.LONGVARBINARY, ProtoMessageType.VENDOR_TYPE_NUMBER + Types.BINARY, + Types.VARBINARY, + Types.LONGVARBINARY, + ProtoMessageType.VENDOR_TYPE_NUMBER, + ProtoMessageType.SHORT_VENDOR_TYPE_NUMBER }) { assertInvalidParameter(params, "1", type); assertInvalidParameter(params, new Object(), type); @@ -576,7 +611,9 @@ public void testSetInvalidParameterWithType() throws SQLException, IOException { Types.NVARCHAR, Types.LONGNVARCHAR, JsonType.VENDOR_TYPE_NUMBER, - PgJsonbType.VENDOR_TYPE_NUMBER + JsonType.SHORT_VENDOR_TYPE_NUMBER, + PgJsonbType.VENDOR_TYPE_NUMBER, + PgJsonbType.SHORT_VENDOR_TYPE_NUMBER }) { assertInvalidParameter(params, new Object(), type); assertInvalidParameter(params, Boolean.TRUE, type); @@ -603,7 +640,9 @@ public void testSetInvalidParameterWithType() throws SQLException, IOException { Types.NVARCHAR, Types.LONGNVARCHAR, JsonType.VENDOR_TYPE_NUMBER, - PgJsonbType.VENDOR_TYPE_NUMBER + JsonType.SHORT_VENDOR_TYPE_NUMBER, + PgJsonbType.VENDOR_TYPE_NUMBER, + PgJsonbType.SHORT_VENDOR_TYPE_NUMBER }) { Reader reader = new StringReader("test"); reader.close(); From ce00b176d39fe728eadd386d4e9794dc1fc0fbca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Knut=20Olav=20L=C3=B8ite?= Date: Wed, 7 Aug 2024 19:13:30 +0200 Subject: [PATCH 19/20] deps: bump Spanner to 6.72.0 (#1698) --- pom.xml | 2 +- .../spanner/jdbc/JdbcConnectionUrlTest.java | 7 ++++-- .../MultiplexedSessionsMockServerTest.java | 22 +++++++------------ 3 files changed, 14 insertions(+), 17 deletions(-) diff --git a/pom.xml b/pom.xml index d510d8133..f205870d9 100644 --- a/pom.xml +++ b/pom.xml @@ -61,7 +61,7 @@ com.google.cloud google-cloud-spanner-bom - 6.71.0 + 6.72.0 pom import diff --git a/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionUrlTest.java b/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionUrlTest.java index bcf8256df..756007190 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionUrlTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/JdbcConnectionUrlTest.java @@ -16,7 +16,7 @@ package com.google.cloud.spanner.jdbc; -import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import com.google.cloud.spanner.connection.AbstractMockServerTest; @@ -103,7 +103,10 @@ public void testMaxSessions() executor1.shutdown(); executor2.shutdown(); } - assertThat(mockSpanner.numSessionsCreated()).isEqualTo(1); + assertEquals(1, mockSpanner.countRequestsOfType(BatchCreateSessionsRequest.class)); + BatchCreateSessionsRequest request = + mockSpanner.getRequestsOfType(BatchCreateSessionsRequest.class).get(0); + assertEquals(1, request.getSessionCount()); } } } diff --git a/src/test/java/com/google/cloud/spanner/jdbc/MultiplexedSessionsMockServerTest.java b/src/test/java/com/google/cloud/spanner/jdbc/MultiplexedSessionsMockServerTest.java index 7688999a1..8415f1a37 100644 --- a/src/test/java/com/google/cloud/spanner/jdbc/MultiplexedSessionsMockServerTest.java +++ b/src/test/java/com/google/cloud/spanner/jdbc/MultiplexedSessionsMockServerTest.java @@ -26,6 +26,7 @@ import com.google.cloud.spanner.MockSpannerServiceImpl.StatementResult; import com.google.cloud.spanner.connection.AbstractMockServerTest; import com.google.cloud.spanner.connection.SpannerPool; +import com.google.spanner.v1.BatchCreateSessionsRequest; import com.google.spanner.v1.CreateSessionRequest; import com.google.spanner.v1.ExecuteSqlRequest; import com.google.spanner.v1.Session; @@ -188,8 +189,6 @@ public void testUsesRegularSessionForQueryInTransaction() throws SQLException { public void testUsesMultiplexedSessionInCombinationWithSessionPoolOptions() throws SQLException { // Create a connection that uses a session pool with MinSessions=0. // This should stop any regular sessions from being created. - // TODO: Modify this test once https://github.com/googleapis/java-spanner/pull/3197 has been - // released. try (Connection connection = DriverManager.getConnection(createUrl() + ";minSessions=0")) { assertTrue(connection.getAutoCommit()); try (ResultSet resultSet = connection.createStatement().executeQuery(SELECT_RANDOM_SQL)) { @@ -199,19 +198,14 @@ public void testUsesMultiplexedSessionInCombinationWithSessionPoolOptions() thro } } } - // TODO: Remove this line once https://github.com/googleapis/java-spanner/pull/3197 has been - // released. - // Adding 'minSessions=X' or 'maxSessions=x' to the connection URL currently disables the use of - // multiplexed sessions due to a bug in the Spanner Java client. - assertEquals(0, mockSpanner.countRequestsOfType(CreateSessionRequest.class)); // Verify that one multiplexed session was created and used. - // TODO: Uncomment - // assertEquals(1, mockSpanner.countRequestsOfType(CreateSessionRequest.class)); - // CreateSessionRequest request = - // mockSpanner.getRequestsOfType(CreateSessionRequest.class).get(0); - // assertTrue(request.getSession().getMultiplexed()); - // // There should be no regular sessions in use. - // assertEquals(0, mockSpanner.countRequestsOfType(BatchCreateSessionsRequest.class)); + assertEquals(1, mockSpanner.countRequestsOfType(CreateSessionRequest.class)); + CreateSessionRequest request = mockSpanner.getRequestsOfType(CreateSessionRequest.class).get(0); + assertTrue(request.getSession().getMultiplexed()); + // There should be no regular sessions in use. + // However, the query that detects the dialect that is used, uses a regular session. + // This should be fixed in the Java client. + assertEquals(1, mockSpanner.countRequestsOfType(BatchCreateSessionsRequest.class)); } } From 5f082df527ee2ff20604538babf8e5de4d2e1940 Mon Sep 17 00:00:00 2001 From: "release-please[bot]" <55107282+release-please[bot]@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:34:19 +0000 Subject: [PATCH 20/20] chore(main): release 2.20.2 (#1678) :robot: I have created a release *beep* *boop* --- ## [2.20.2](https://togithub.com/googleapis/java-spanner-jdbc/compare/v2.20.1...v2.20.2) (2024-08-07) ### Bug Fixes * Support getShort for DATA_TYPE in TypeInfo ([#1691](https://togithub.com/googleapis/java-spanner-jdbc/issues/1691)) ([828aff6](https://togithub.com/googleapis/java-spanner-jdbc/commit/828aff6f7015b5f91ebbc2ad54aeeecf5515a9bd)) ### Dependencies * Bump Spanner to 6.72.0 ([#1698](https://togithub.com/googleapis/java-spanner-jdbc/issues/1698)) ([ce00b17](https://togithub.com/googleapis/java-spanner-jdbc/commit/ce00b176d39fe728eadd386d4e9794dc1fc0fbca)) * Update dependency com.google.api.grpc:proto-google-cloud-trace-v1 to v2.47.0 ([#1695](https://togithub.com/googleapis/java-spanner-jdbc/issues/1695)) ([148c655](https://togithub.com/googleapis/java-spanner-jdbc/commit/148c655a8bd1309250b5158d0f20a167e89bd9fe)) * Update dependency com.google.cloud:google-cloud-trace to v2.47.0 ([#1696](https://togithub.com/googleapis/java-spanner-jdbc/issues/1696)) ([c6a54f7](https://togithub.com/googleapis/java-spanner-jdbc/commit/c6a54f7a3045fc711fcad8d16294c67aa8eb8810)) * Update dependency com.google.cloud:sdk-platform-java-config to v3.33.0 ([#1693](https://togithub.com/googleapis/java-spanner-jdbc/issues/1693)) ([08011a5](https://togithub.com/googleapis/java-spanner-jdbc/commit/08011a520a2fb14d06614da5e2c7b9ae47d6c6f1)) * Update dependency com.google.cloud.opentelemetry:exporter-trace to v0.31.0 ([#1679](https://togithub.com/googleapis/java-spanner-jdbc/issues/1679)) ([ddf47f4](https://togithub.com/googleapis/java-spanner-jdbc/commit/ddf47f4fc7e1c05e6e3086ada0ff3b2c1efeb2af)) * Update dependency io.opentelemetry:opentelemetry-bom to v1.40.0 ([#1676](https://togithub.com/googleapis/java-spanner-jdbc/issues/1676)) ([faf7c49](https://togithub.com/googleapis/java-spanner-jdbc/commit/faf7c4908a926cd7a10ea0b860babcaa97c4c7e1)) * Update dependency org.hamcrest:hamcrest to v3 ([#1697](https://togithub.com/googleapis/java-spanner-jdbc/issues/1697)) ([3933cf2](https://togithub.com/googleapis/java-spanner-jdbc/commit/3933cf2c4099e0d06c1dc4e4583c11ba5e4eae19)) * Update dependency org.springframework.boot:spring-boot-starter-data-jdbc to v3.3.2 ([#1685](https://togithub.com/googleapis/java-spanner-jdbc/issues/1685)) ([6a57b49](https://togithub.com/googleapis/java-spanner-jdbc/commit/6a57b49a34f2b44f42f6c07eaf5da063a1d648d0)) * Update dependency org.springframework.boot:spring-boot-starter-parent to v3.3.2 ([#1686](https://togithub.com/googleapis/java-spanner-jdbc/issues/1686)) ([2be70c7](https://togithub.com/googleapis/java-spanner-jdbc/commit/2be70c74f673c796d7b366b56644b6d00038bc07)) * Update dependency org.springframework.data:spring-data-bom to v2024.0.2 ([#1680](https://togithub.com/googleapis/java-spanner-jdbc/issues/1680)) ([23934f7](https://togithub.com/googleapis/java-spanner-jdbc/commit/23934f7f38f5c99b7a6859ab69525ce368317128)) --- This PR was generated with [Release Please](https://togithub.com/googleapis/release-please). See [documentation](https://togithub.com/googleapis/release-please#release-please). --- CHANGELOG.md | 21 +++++++++++++++++++++ pom.xml | 2 +- samples/snapshot/pom.xml | 2 +- versions.txt | 2 +- 4 files changed, 24 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 61628c9de..424389937 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,26 @@ # Changelog +## [2.20.2](https://github.com/googleapis/java-spanner-jdbc/compare/v2.20.1...v2.20.2) (2024-08-07) + + +### Bug Fixes + +* Support getShort for DATA_TYPE in TypeInfo ([#1691](https://github.com/googleapis/java-spanner-jdbc/issues/1691)) ([828aff6](https://github.com/googleapis/java-spanner-jdbc/commit/828aff6f7015b5f91ebbc2ad54aeeecf5515a9bd)) + + +### Dependencies + +* Bump Spanner to 6.72.0 ([#1698](https://github.com/googleapis/java-spanner-jdbc/issues/1698)) ([ce00b17](https://github.com/googleapis/java-spanner-jdbc/commit/ce00b176d39fe728eadd386d4e9794dc1fc0fbca)) +* Update dependency com.google.api.grpc:proto-google-cloud-trace-v1 to v2.47.0 ([#1695](https://github.com/googleapis/java-spanner-jdbc/issues/1695)) ([148c655](https://github.com/googleapis/java-spanner-jdbc/commit/148c655a8bd1309250b5158d0f20a167e89bd9fe)) +* Update dependency com.google.cloud:google-cloud-trace to v2.47.0 ([#1696](https://github.com/googleapis/java-spanner-jdbc/issues/1696)) ([c6a54f7](https://github.com/googleapis/java-spanner-jdbc/commit/c6a54f7a3045fc711fcad8d16294c67aa8eb8810)) +* Update dependency com.google.cloud:sdk-platform-java-config to v3.33.0 ([#1693](https://github.com/googleapis/java-spanner-jdbc/issues/1693)) ([08011a5](https://github.com/googleapis/java-spanner-jdbc/commit/08011a520a2fb14d06614da5e2c7b9ae47d6c6f1)) +* Update dependency com.google.cloud.opentelemetry:exporter-trace to v0.31.0 ([#1679](https://github.com/googleapis/java-spanner-jdbc/issues/1679)) ([ddf47f4](https://github.com/googleapis/java-spanner-jdbc/commit/ddf47f4fc7e1c05e6e3086ada0ff3b2c1efeb2af)) +* Update dependency io.opentelemetry:opentelemetry-bom to v1.40.0 ([#1676](https://github.com/googleapis/java-spanner-jdbc/issues/1676)) ([faf7c49](https://github.com/googleapis/java-spanner-jdbc/commit/faf7c4908a926cd7a10ea0b860babcaa97c4c7e1)) +* Update dependency org.hamcrest:hamcrest to v3 ([#1697](https://github.com/googleapis/java-spanner-jdbc/issues/1697)) ([3933cf2](https://github.com/googleapis/java-spanner-jdbc/commit/3933cf2c4099e0d06c1dc4e4583c11ba5e4eae19)) +* Update dependency org.springframework.boot:spring-boot-starter-data-jdbc to v3.3.2 ([#1685](https://github.com/googleapis/java-spanner-jdbc/issues/1685)) ([6a57b49](https://github.com/googleapis/java-spanner-jdbc/commit/6a57b49a34f2b44f42f6c07eaf5da063a1d648d0)) +* Update dependency org.springframework.boot:spring-boot-starter-parent to v3.3.2 ([#1686](https://github.com/googleapis/java-spanner-jdbc/issues/1686)) ([2be70c7](https://github.com/googleapis/java-spanner-jdbc/commit/2be70c74f673c796d7b366b56644b6d00038bc07)) +* Update dependency org.springframework.data:spring-data-bom to v2024.0.2 ([#1680](https://github.com/googleapis/java-spanner-jdbc/issues/1680)) ([23934f7](https://github.com/googleapis/java-spanner-jdbc/commit/23934f7f38f5c99b7a6859ab69525ce368317128)) + ## [2.20.1](https://github.com/googleapis/java-spanner-jdbc/compare/v2.20.0...v2.20.1) (2024-07-04) diff --git a/pom.xml b/pom.xml index f205870d9..9f17e9c78 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 google-cloud-spanner-jdbc - 2.20.2-SNAPSHOT + 2.20.2 jar Google Cloud Spanner JDBC https://github.com/googleapis/java-spanner-jdbc diff --git a/samples/snapshot/pom.xml b/samples/snapshot/pom.xml index cc99c9b5e..ef21adcf1 100644 --- a/samples/snapshot/pom.xml +++ b/samples/snapshot/pom.xml @@ -28,7 +28,7 @@ com.google.cloud google-cloud-spanner-jdbc - 2.20.2-SNAPSHOT + 2.20.2 diff --git a/versions.txt b/versions.txt index 807395b03..6f8ffa714 100644 --- a/versions.txt +++ b/versions.txt @@ -1,4 +1,4 @@ # Format: # module:released-version:current-version -google-cloud-spanner-jdbc:2.20.1:2.20.2-SNAPSHOT +google-cloud-spanner-jdbc:2.20.2:2.20.2