refactor: Remove trailing dots from exception messages.

michael-simons · michael-simons · commit dd425d2d2830 · 2024-03-11T10:35:21.000+01:00
For prior art see: spring-projects/spring-data-commons#2603 Closes #548
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/CallableStatementImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/CallableStatementImpl.java
@@ -924,7 +924,7 @@ private void assertParameterType(ParameterType parameterType) throws SQLExceptio
 		}
 		else {
 			if (this.parameterType != parameterType) {
-				throw new SQLException(String.format("%s parameter can not be mixed with %s parameter(s).",
+				throw new SQLException(String.format("%s parameter can not be mixed with %s parameter(s)",
 						parameterType, this.parameterType));
 			}
 		}
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ConnectionImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ConnectionImpl.java
@@ -177,7 +177,7 @@ public void setAutoCommit(boolean autoCommit) throws SQLException {
 
 		if (this.transaction != null) {
 			if (Neo4jTransaction.State.OPEN_FAILED == this.transaction.getState()) {
-				throw new SQLException("The existing transaction must be rolled back explicitly.");
+				throw new SQLException("The existing transaction must be rolled back explicitly");
 			}
 			if (this.transaction.isRunnable()) {
 				this.transaction.commit();
@@ -197,10 +197,10 @@ public boolean getAutoCommit() throws SQLException {
 	public void commit() throws SQLException {
 		assertIsOpen();
 		if (this.transaction == null) {
-			throw new SQLException("There is no transaction to commit.");
+			throw new SQLException("There is no transaction to commit");
 		}
 		if (this.transaction.isAutoCommit()) {
-			throw new SQLException("Auto commit transaction may not be managed explicitly.");
+			throw new SQLException("Auto commit transaction may not be managed explicitly");
 		}
 		this.transaction.commit();
 	}
@@ -209,10 +209,10 @@ public void commit() throws SQLException {
 	public void rollback() throws SQLException {
 		assertIsOpen();
 		if (this.transaction == null) {
-			throw new SQLException("There is no transaction to rollback.");
+			throw new SQLException("There is no transaction to rollback");
 		}
 		if (this.transaction.isAutoCommit()) {
-			throw new SQLException("Auto commit transaction may not be managed explicitly.");
+			throw new SQLException("Auto commit transaction may not be managed explicitly");
 		}
 		this.transaction.rollback();
 	}
@@ -262,7 +262,7 @@ public DatabaseMetaData getMetaData() throws SQLException {
 	public void setReadOnly(boolean readOnly) throws SQLException {
 		assertIsOpen();
 		if (this.transaction != null && this.transaction.isOpen()) {
-			throw new SQLException("Updating read only setting during an unfinished transaction is not permitted.");
+			throw new SQLException("Updating read only setting during an unfinished transaction is not permitted");
 		}
 		this.readOnly = readOnly;
 	}
@@ -287,7 +287,7 @@ public String getCatalog() throws SQLException {
 
 	@Override
 	public void setTransactionIsolation(int level) throws SQLException {
-		throw new SQLException("Setting transaction isolation level is not supported.");
+		throw new SQLException("Setting transaction isolation level is not supported");
 	}
 
 	@Override
@@ -461,7 +461,7 @@ public SQLXML createSQLXML() throws SQLException {
 	@Override
 	public boolean isValid(int timeout) throws SQLException {
 		if (timeout < 0) {
-			throw new SQLException("Negative timeout is not supported.");
+			throw new SQLException("Negative timeout is not supported");
 		}
 		if (this.closed) {
 			return false;
@@ -606,7 +606,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
 			return iface.cast(this);
 		}
 		else {
-			throw new SQLException("This object does not implement the given interface.");
+			throw new SQLException("This object does not implement the given interface");
 		}
 	}
 
@@ -617,7 +617,7 @@ public boolean isWrapperFor(Class<?> iface) throws SQLException {
 
 	private void assertIsOpen() throws SQLException {
 		if (this.closed) {
-			throw new SQLException("The connection is closed.");
+			throw new SQLException("The connection is closed");
 		}
 	}
 
@@ -632,7 +632,7 @@ Neo4jTransaction getTransaction(boolean autoCommitCheck) throws SQLException {
 		}
 		if (this.transaction != null && this.transaction.isOpen()) {
 			if (autoCommitCheck && this.transaction.isAutoCommit()) {
-				throw new SQLException("Only a single autocommit transaction is supported.");
+				throw new SQLException("Only a single autocommit transaction is supported");
 			}
 		}
 		else {
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/DatabaseMetadataImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/DatabaseMetadataImpl.java
@@ -1418,7 +1418,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
 			return iface.cast(this);
 		}
 		else {
-			throw new SQLException("This object does not implement the given interface.");
+			throw new SQLException("This object does not implement the given interface");
 		}
 	}
 
@@ -1462,13 +1462,13 @@ public boolean hasMore() {
 
 	private static void assertSchemaIsPublicOrNull(String schemaPattern) throws SQLException {
 		if (schemaPattern != null && !"public".equals(schemaPattern)) {
-			throw new SQLException("Schema must be public or null.");
+			throw new SQLException("Schema must be public or null");
 		}
 	}
 
 	private static void assertCatalogIsNullOrEmpty(String catalog) throws SQLException {
 		if (catalog != null && !catalog.isEmpty()) {
-			throw new SQLException("Catalog is not applicable to Neo4j please leave null.");
+			throw new SQLException("Catalog is not applicable to Neo4j please leave null");
 		}
 	}
 
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/Neo4jDataSource.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/Neo4jDataSource.java
@@ -213,7 +213,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
 			return iface.cast(this);
 		}
 		else {
-			throw new SQLException("This object does not implement the given interface.");
+			throw new SQLException("This object does not implement the given interface");
 		}
 	}
 
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/Neo4jDriver.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/Neo4jDriver.java
@@ -311,7 +311,7 @@ static Map<String, String> mergeConfig(String[] urlParams, Properties jdbcProper
 	@Override
 	public boolean acceptsURL(String url) throws SQLException {
 		if (url == null) {
-			throw new SQLException("url cannot be null.");
+			throw new SQLException("url cannot be null");
 		}
 
 		return URL_PATTERN.matcher(url).matches();
@@ -417,13 +417,13 @@ public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws
 
 	private static DriverConfig parseConfig(String url, Properties info) throws SQLException {
 		if (url == null || info == null) {
-			throw new SQLException("url and info cannot be null.");
+			throw new SQLException("url and info cannot be null");
 		}
 
 		var matcher = URL_PATTERN.matcher(url);
 
 		if (!matcher.matches()) {
-			throw new SQLException("Invalid url.");
+			throw new SQLException("Invalid url");
 		}
 
 		var urlParams = splitUrlParams(matcher.group("urlParams"));
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ParameterMetaDataImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ParameterMetaDataImpl.java
@@ -75,7 +75,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
 			return iface.cast(this);
 		}
 		else {
-			throw new SQLException("This object does not implement the given interface.");
+			throw new SQLException("This object does not implement the given interface");
 		}
 	}
 
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ResultSetImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ResultSetImpl.java
@@ -147,7 +147,7 @@ public boolean next() throws SQLException {
 
 	private boolean next0() throws SQLException {
 		if (this.closed) {
-			throw new SQLException("This result set is closed.");
+			throw new SQLException("This result set is closed");
 		}
 		if (this.remainingRowAllowance == 0) {
 			return false;
@@ -184,7 +184,7 @@ public void close() throws SQLException {
 	public boolean wasNull() throws SQLException {
 		assertIsOpen();
 		if (this.value == null) {
-			throw new SQLException("No column has been read prior to this call.");
+			throw new SQLException("No column has been read prior to this call");
 		}
 		return Type.NULL.isTypeOf(this.value);
 	}
@@ -389,7 +389,7 @@ public int findColumn(String columnLabel) throws SQLException {
 		assertIsOpen();
 		var index = this.keys.indexOf(columnLabel);
 		if (index == -1) {
-			throw new SQLException("No such column is present.");
+			throw new SQLException("No such column is present");
 		}
 		return ++index;
 	}
@@ -1152,7 +1152,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
 			return iface.cast(this);
 		}
 		else {
-			throw new SQLException("This object does not implement the given interface.");
+			throw new SQLException("This object does not implement the given interface");
 		}
 	}
 
@@ -1219,7 +1219,7 @@ private static String mapToString(Value value, int maxFieldSize) throws SQLExcep
 		if (Type.NULL.isTypeOf(value)) {
 			return null;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to String.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to String", value.type()));
 	}
 
 	private static boolean mapToBoolean(Value value) throws SQLException {
@@ -1238,7 +1238,7 @@ else if (number == 1) {
 				return true;
 			}
 			else {
-				throw new SQLException("Number values can not be mapped to boolean aside from 0 and 1 values.");
+				throw new SQLException("Number values can not be mapped to boolean aside from 0 and 1 values");
 			}
 		}
 		if (Type.STRING.isTypeOf(value)) {
@@ -1250,10 +1250,10 @@ else if ("1".equals(string)) {
 				return true;
 			}
 			else {
-				throw new SQLException("String values can not be mapped to boolean aside from '0' and '1' values.");
+				throw new SQLException("String values can not be mapped to boolean aside from '0' and '1' values");
 			}
 		}
-		throw new SQLException(String.format("%s value can not be mapped to boolean.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to boolean", value.type()));
 	}
 
 	private static Byte mapToByte(Value value) throws SQLException {
@@ -1262,12 +1262,12 @@ private static Byte mapToByte(Value value) throws SQLException {
 			if (longValue >= Byte.MIN_VALUE && longValue <= Byte.MAX_VALUE) {
 				return (byte) longValue;
 			}
-			throw new SQLException("The number is out of byte range.");
+			throw new SQLException("The number is out of byte range");
 		}
 		if (Type.NULL.isTypeOf(value)) {
 			return (byte) 0;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to byte.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to byte", value.type()));
 	}
 
 	private static Short mapToShort(Value value) throws SQLException {
@@ -1276,12 +1276,12 @@ private static Short mapToShort(Value value) throws SQLException {
 			if (longValue >= Short.MIN_VALUE && longValue <= Short.MAX_VALUE) {
 				return (short) longValue;
 			}
-			throw new SQLException("The number is out of short range.");
+			throw new SQLException("The number is out of short range");
 		}
 		if (Type.NULL.isTypeOf(value)) {
 			return (short) 0;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to short.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to short", value.type()));
 	}
 
 	private static int mapToInteger(Value value) throws SQLException {
@@ -1290,12 +1290,12 @@ private static int mapToInteger(Value value) throws SQLException {
 			if (longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE) {
 				return (int) longValue;
 			}
-			throw new SQLException("The number is out of int range.");
+			throw new SQLException("The number is out of int range");
 		}
 		if (Type.NULL.isTypeOf(value)) {
 			return 0;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to int.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to int", value.type()));
 	}
 
 	private static long mapToLong(Value value) throws SQLException {
@@ -1305,7 +1305,7 @@ private static long mapToLong(Value value) throws SQLException {
 		if (Type.NULL.isTypeOf(value)) {
 			return 0L;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to long.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to long", value.type()));
 	}
 
 	private static float mapToFloat(Value value) throws SQLException {
@@ -1315,12 +1315,12 @@ private static float mapToFloat(Value value) throws SQLException {
 			if (Double.compare(doubleValue, floatValue) == 0) {
 				return floatValue;
 			}
-			throw new SQLException("The number is out of float range.");
+			throw new SQLException("The number is out of float range");
 		}
 		if (Type.NULL.isTypeOf(value)) {
 			return 0.0f;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to float.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to float", value.type()));
 	}
 
 	private static double mapToDouble(Value value) throws SQLException {
@@ -1330,7 +1330,7 @@ private static double mapToDouble(Value value) throws SQLException {
 		if (Type.NULL.isTypeOf(value)) {
 			return 0.0;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to double.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to double", value.type()));
 	}
 
 	private static byte[] mapToBytes(Value value, int maxFieldSize) throws SQLException {
@@ -1340,7 +1340,7 @@ private static byte[] mapToBytes(Value value, int maxFieldSize) throws SQLExcept
 		if (Type.BYTES.isTypeOf(value)) {
 			return truncate(value.asByteArray(), maxFieldSize);
 		}
-		throw new SQLException(String.format("%s value can not be mapped to byte array.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to byte array", value.type()));
 	}
 
 	private static Reader mapToReader(Value value, int maxFieldSize) throws SQLException {
@@ -1350,7 +1350,7 @@ private static Reader mapToReader(Value value, int maxFieldSize) throws SQLExcep
 		if (Type.NULL.isTypeOf(value)) {
 			return null;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to Reader.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to Reader", value.type()));
 	}
 
 	@SuppressWarnings("BigDecimalMethodWithoutRoundingCalled")
@@ -1361,7 +1361,8 @@ private static BigDecimal mapToBigDecimal(Value value, Integer scale) throws SQL
 			case INTEGER -> BigDecimal.valueOf(value.asLong());
 			case FLOAT -> BigDecimal.valueOf(value.asDouble());
 			case NULL -> null;
-			default -> throw new SQLException(String.format("%s value can not be mapped to BigDecimal.", value.type()));
+			default -> throw new SQLException(
+					String.format("%s value can not be mapped to java.math.BigDecimal", value.type()));
 		};
 
 		if (result != null && scale != null) {
@@ -1383,7 +1384,7 @@ private static InputStream mapToAsciiStream(Value value, int maxFieldSize) throw
 		if (Type.NULL.isTypeOf(value)) {
 			return null;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to InputStream.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to java.io.InputStream", value.type()));
 	}
 
 	private static InputStream mapToBinaryStream(Value value, int maxFieldSize) throws SQLException {
@@ -1393,7 +1394,7 @@ private static InputStream mapToBinaryStream(Value value, int maxFieldSize) thro
 		if (Type.NULL.isTypeOf(value)) {
 			return null;
 		}
-		throw new SQLException(String.format("%s value can not be mapped to InputStream.", value.type()));
+		throw new SQLException(String.format("%s value can not be mapped to java.io.InputStream", value.type()));
 	}
 
 	private static Object mapToObject(Value value, int maxFieldSize) {
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ResultSetMetaDataImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ResultSetMetaDataImpl.java
@@ -251,7 +251,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
 			return iface.cast(this);
 		}
 		else {
-			throw new SQLException("This object does not implement the given interface.");
+			throw new SQLException("This object does not implement the given interface");
 		}
 	}
 
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/StatementImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/StatementImpl.java
diff --git a/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ThrowingTransactionImpl.java b/neo4j-jdbc/src/main/java/org/neo4j/jdbc/ThrowingTransactionImpl.java

Original file line number	Diff line number	Diff line change
`@@ -924,7 +924,7 @@ private void assertParameterType(ParameterType parameterType) throws SQLExceptio`
`924`	`924`	`}`
`925`	`925`	`else {`
`926`	`926`	`if (this.parameterType != parameterType) {`
`927`		`- throw new SQLException(String.format("%s parameter can not be mixed with %s parameter(s).",`
	`927`	`+ throw new SQLException(String.format("%s parameter can not be mixed with %s parameter(s)",`
`928`	`928`	`parameterType, this.parameterType));`
`929`	`929`	`}`
`930`	`930`	`}`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ public void setAutoCommit(boolean autoCommit) throws SQLException {`
`177`	`177`
`178`	`178`	`if (this.transaction != null) {`
`179`	`179`	`if (Neo4jTransaction.State.OPEN_FAILED == this.transaction.getState()) {`
`180`		`- throw new SQLException("The existing transaction must be rolled back explicitly.");`
	`180`	`+ throw new SQLException("The existing transaction must be rolled back explicitly");`
`181`	`181`	`}`
`182`	`182`	`if (this.transaction.isRunnable()) {`
`183`	`183`	`this.transaction.commit();`
`@@ -197,10 +197,10 @@ public boolean getAutoCommit() throws SQLException {`
`197`	`197`	`public void commit() throws SQLException {`
`198`	`198`	`assertIsOpen();`
`199`	`199`	`if (this.transaction == null) {`
`200`		`- throw new SQLException("There is no transaction to commit.");`
	`200`	`+ throw new SQLException("There is no transaction to commit");`
`201`	`201`	`}`
`202`	`202`	`if (this.transaction.isAutoCommit()) {`
`203`		`- throw new SQLException("Auto commit transaction may not be managed explicitly.");`
	`203`	`+ throw new SQLException("Auto commit transaction may not be managed explicitly");`
`204`	`204`	`}`
`205`	`205`	`this.transaction.commit();`
`206`	`206`	`}`
`@@ -209,10 +209,10 @@ public void commit() throws SQLException {`
`209`	`209`	`public void rollback() throws SQLException {`
`210`	`210`	`assertIsOpen();`
`211`	`211`	`if (this.transaction == null) {`
`212`		`- throw new SQLException("There is no transaction to rollback.");`
	`212`	`+ throw new SQLException("There is no transaction to rollback");`
`213`	`213`	`}`
`214`	`214`	`if (this.transaction.isAutoCommit()) {`
`215`		`- throw new SQLException("Auto commit transaction may not be managed explicitly.");`
	`215`	`+ throw new SQLException("Auto commit transaction may not be managed explicitly");`
`216`	`216`	`}`
`217`	`217`	`this.transaction.rollback();`
`218`	`218`	`}`
`@@ -262,7 +262,7 @@ public DatabaseMetaData getMetaData() throws SQLException {`
`262`	`262`	`public void setReadOnly(boolean readOnly) throws SQLException {`
`263`	`263`	`assertIsOpen();`
`264`	`264`	`if (this.transaction != null && this.transaction.isOpen()) {`
`265`		`- throw new SQLException("Updating read only setting during an unfinished transaction is not permitted.");`
	`265`	`+ throw new SQLException("Updating read only setting during an unfinished transaction is not permitted");`
`266`	`266`	`}`
`267`	`267`	`this.readOnly = readOnly;`
`268`	`268`	`}`
`@@ -287,7 +287,7 @@ public String getCatalog() throws SQLException {`
`287`	`287`
`288`	`288`	`@Override`
`289`	`289`	`public void setTransactionIsolation(int level) throws SQLException {`
`290`		`- throw new SQLException("Setting transaction isolation level is not supported.");`
	`290`	`+ throw new SQLException("Setting transaction isolation level is not supported");`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`@Override`
`@@ -461,7 +461,7 @@ public SQLXML createSQLXML() throws SQLException {`
`461`	`461`	`@Override`
`462`	`462`	`public boolean isValid(int timeout) throws SQLException {`
`463`	`463`	`if (timeout < 0) {`
`464`		`- throw new SQLException("Negative timeout is not supported.");`
	`464`	`+ throw new SQLException("Negative timeout is not supported");`
`465`	`465`	`}`
`466`	`466`	`if (this.closed) {`
`467`	`467`	`return false;`
`@@ -606,7 +606,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {`
`606`	`606`	`return iface.cast(this);`
`607`	`607`	`}`
`608`	`608`	`else {`
`609`		`- throw new SQLException("This object does not implement the given interface.");`
	`609`	`+ throw new SQLException("This object does not implement the given interface");`
`610`	`610`	`}`
`611`	`611`	`}`
`612`	`612`
`@@ -617,7 +617,7 @@ public boolean isWrapperFor(Class<?> iface) throws SQLException {`
`617`	`617`
`618`	`618`	`private void assertIsOpen() throws SQLException {`
`619`	`619`	`if (this.closed) {`
`620`		`- throw new SQLException("The connection is closed.");`
	`620`	`+ throw new SQLException("The connection is closed");`
`621`	`621`	`}`
`622`	`622`	`}`
`623`	`623`
`@@ -632,7 +632,7 @@ Neo4jTransaction getTransaction(boolean autoCommitCheck) throws SQLException {`
`632`	`632`	`}`
`633`	`633`	`if (this.transaction != null && this.transaction.isOpen()) {`
`634`	`634`	`if (autoCommitCheck && this.transaction.isAutoCommit()) {`
`635`		`- throw new SQLException("Only a single autocommit transaction is supported.");`
	`635`	`+ throw new SQLException("Only a single autocommit transaction is supported");`
`636`	`636`	`}`
`637`	`637`	`}`
`638`	`638`	`else {`
Original file line number	Diff line number	Diff line change
`@@ -1418,7 +1418,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {`
`1418`	`1418`	`return iface.cast(this);`
`1419`	`1419`	`}`
`1420`	`1420`	`else {`
`1421`		`- throw new SQLException("This object does not implement the given interface.");`
	`1421`	`+ throw new SQLException("This object does not implement the given interface");`
`1422`	`1422`	`}`
`1423`	`1423`	`}`
`1424`	`1424`
`@@ -1462,13 +1462,13 @@ public boolean hasMore() {`
`1462`	`1462`
`1463`	`1463`	`private static void assertSchemaIsPublicOrNull(String schemaPattern) throws SQLException {`
`1464`	`1464`	`if (schemaPattern != null && !"public".equals(schemaPattern)) {`
`1465`		`- throw new SQLException("Schema must be public or null.");`
	`1465`	`+ throw new SQLException("Schema must be public or null");`
`1466`	`1466`	`}`
`1467`	`1467`	`}`
`1468`	`1468`
`1469`	`1469`	`private static void assertCatalogIsNullOrEmpty(String catalog) throws SQLException {`
`1470`	`1470`	`if (catalog != null && !catalog.isEmpty()) {`
`1471`		`- throw new SQLException("Catalog is not applicable to Neo4j please leave null.");`
	`1471`	`+ throw new SQLException("Catalog is not applicable to Neo4j please leave null");`
`1472`	`1472`	`}`
`1473`	`1473`	`}`
`1474`	`1474`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {`
`213`	`213`	`return iface.cast(this);`
`214`	`214`	`}`
`215`	`215`	`else {`
`216`		`- throw new SQLException("This object does not implement the given interface.");`
	`216`	`+ throw new SQLException("This object does not implement the given interface");`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`
Original file line number	Diff line number	Diff line change
`@@ -311,7 +311,7 @@ static Map<String, String> mergeConfig(String[] urlParams, Properties jdbcProper`
`311`	`311`	`@Override`
`312`	`312`	`public boolean acceptsURL(String url) throws SQLException {`
`313`	`313`	`if (url == null) {`
`314`		`- throw new SQLException("url cannot be null.");`
	`314`	`+ throw new SQLException("url cannot be null");`
`315`	`315`	`}`
`316`	`316`
`317`	`317`	`return URL_PATTERN.matcher(url).matches();`
`@@ -417,13 +417,13 @@ public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws`
`417`	`417`
`418`	`418`	`private static DriverConfig parseConfig(String url, Properties info) throws SQLException {`
`419`	`419`	`if (url == null \|\| info == null) {`
`420`		`- throw new SQLException("url and info cannot be null.");`
	`420`	`+ throw new SQLException("url and info cannot be null");`
`421`	`421`	`}`
`422`	`422`
`423`	`423`	`var matcher = URL_PATTERN.matcher(url);`
`424`	`424`
`425`	`425`	`if (!matcher.matches()) {`
`426`		`- throw new SQLException("Invalid url.");`
	`426`	`+ throw new SQLException("Invalid url");`
`427`	`427`	`}`
`428`	`428`
`429`	`429`	`var urlParams = splitUrlParams(matcher.group("urlParams"));`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {`
`75`	`75`	`return iface.cast(this);`
`76`	`76`	`}`
`77`	`77`	`else {`
`78`		`- throw new SQLException("This object does not implement the given interface.");`
	`78`	`+ throw new SQLException("This object does not implement the given interface");`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ public boolean next() throws SQLException {`
`147`	`147`
`148`	`148`	`private boolean next0() throws SQLException {`
`149`	`149`	`if (this.closed) {`
`150`		`- throw new SQLException("This result set is closed.");`
	`150`	`+ throw new SQLException("This result set is closed");`
`151`	`151`	`}`
`152`	`152`	`if (this.remainingRowAllowance == 0) {`
`153`	`153`	`return false;`
`@@ -184,7 +184,7 @@ public void close() throws SQLException {`
`184`	`184`	`public boolean wasNull() throws SQLException {`
`185`	`185`	`assertIsOpen();`
`186`	`186`	`if (this.value == null) {`
`187`		`- throw new SQLException("No column has been read prior to this call.");`
	`187`	`+ throw new SQLException("No column has been read prior to this call");`
`188`	`188`	`}`
`189`	`189`	`return Type.NULL.isTypeOf(this.value);`
`190`	`190`	`}`
`@@ -389,7 +389,7 @@ public int findColumn(String columnLabel) throws SQLException {`
`389`	`389`	`assertIsOpen();`
`390`	`390`	`var index = this.keys.indexOf(columnLabel);`
`391`	`391`	`if (index == -1) {`
`392`		`- throw new SQLException("No such column is present.");`
	`392`	`+ throw new SQLException("No such column is present");`
`393`	`393`	`}`
`394`	`394`	`return ++index;`
`395`	`395`	`}`
`@@ -1152,7 +1152,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {`
`1152`	`1152`	`return iface.cast(this);`
`1153`	`1153`	`}`
`1154`	`1154`	`else {`
`1155`		`- throw new SQLException("This object does not implement the given interface.");`
	`1155`	`+ throw new SQLException("This object does not implement the given interface");`
`1156`	`1156`	`}`
`1157`	`1157`	`}`
`1158`	`1158`
`@@ -1219,7 +1219,7 @@ private static String mapToString(Value value, int maxFieldSize) throws SQLExcep`
`1219`	`1219`	`if (Type.NULL.isTypeOf(value)) {`
`1220`	`1220`	`return null;`
`1221`	`1221`	`}`
`1222`		`- throw new SQLException(String.format("%s value can not be mapped to String.", value.type()));`
	`1222`	`+ throw new SQLException(String.format("%s value can not be mapped to String", value.type()));`
`1223`	`1223`	`}`
`1224`	`1224`
`1225`	`1225`	`private static boolean mapToBoolean(Value value) throws SQLException {`
`@@ -1238,7 +1238,7 @@ else if (number == 1) {`
`1238`	`1238`	`return true;`
`1239`	`1239`	`}`
`1240`	`1240`	`else {`
`1241`		`- throw new SQLException("Number values can not be mapped to boolean aside from 0 and 1 values.");`
	`1241`	`+ throw new SQLException("Number values can not be mapped to boolean aside from 0 and 1 values");`
`1242`	`1242`	`}`
`1243`	`1243`	`}`
`1244`	`1244`	`if (Type.STRING.isTypeOf(value)) {`
`@@ -1250,10 +1250,10 @@ else if ("1".equals(string)) {`
`1250`	`1250`	`return true;`
`1251`	`1251`	`}`
`1252`	`1252`	`else {`
`1253`		`- throw new SQLException("String values can not be mapped to boolean aside from '0' and '1' values.");`
	`1253`	`+ throw new SQLException("String values can not be mapped to boolean aside from '0' and '1' values");`
`1254`	`1254`	`}`
`1255`	`1255`	`}`
`1256`		`- throw new SQLException(String.format("%s value can not be mapped to boolean.", value.type()));`
	`1256`	`+ throw new SQLException(String.format("%s value can not be mapped to boolean", value.type()));`
`1257`	`1257`	`}`
`1258`	`1258`
`1259`	`1259`	`private static Byte mapToByte(Value value) throws SQLException {`
`@@ -1262,12 +1262,12 @@ private static Byte mapToByte(Value value) throws SQLException {`
`1262`	`1262`	`if (longValue >= Byte.MIN_VALUE && longValue <= Byte.MAX_VALUE) {`
`1263`	`1263`	`return (byte) longValue;`
`1264`	`1264`	`}`
`1265`		`- throw new SQLException("The number is out of byte range.");`
	`1265`	`+ throw new SQLException("The number is out of byte range");`
`1266`	`1266`	`}`
`1267`	`1267`	`if (Type.NULL.isTypeOf(value)) {`
`1268`	`1268`	`return (byte) 0;`
`1269`	`1269`	`}`
`1270`		`- throw new SQLException(String.format("%s value can not be mapped to byte.", value.type()));`
	`1270`	`+ throw new SQLException(String.format("%s value can not be mapped to byte", value.type()));`
`1271`	`1271`	`}`
`1272`	`1272`
`1273`	`1273`	`private static Short mapToShort(Value value) throws SQLException {`
`@@ -1276,12 +1276,12 @@ private static Short mapToShort(Value value) throws SQLException {`
`1276`	`1276`	`if (longValue >= Short.MIN_VALUE && longValue <= Short.MAX_VALUE) {`
`1277`	`1277`	`return (short) longValue;`
`1278`	`1278`	`}`
`1279`		`- throw new SQLException("The number is out of short range.");`
	`1279`	`+ throw new SQLException("The number is out of short range");`
`1280`	`1280`	`}`
`1281`	`1281`	`if (Type.NULL.isTypeOf(value)) {`
`1282`	`1282`	`return (short) 0;`
`1283`	`1283`	`}`
`1284`		`- throw new SQLException(String.format("%s value can not be mapped to short.", value.type()));`
	`1284`	`+ throw new SQLException(String.format("%s value can not be mapped to short", value.type()));`
`1285`	`1285`	`}`
`1286`	`1286`
`1287`	`1287`	`private static int mapToInteger(Value value) throws SQLException {`
`@@ -1290,12 +1290,12 @@ private static int mapToInteger(Value value) throws SQLException {`
`1290`	`1290`	`if (longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE) {`
`1291`	`1291`	`return (int) longValue;`
`1292`	`1292`	`}`
`1293`		`- throw new SQLException("The number is out of int range.");`
	`1293`	`+ throw new SQLException("The number is out of int range");`
`1294`	`1294`	`}`
`1295`	`1295`	`if (Type.NULL.isTypeOf(value)) {`
`1296`	`1296`	`return 0;`
`1297`	`1297`	`}`
`1298`		`- throw new SQLException(String.format("%s value can not be mapped to int.", value.type()));`
	`1298`	`+ throw new SQLException(String.format("%s value can not be mapped to int", value.type()));`
`1299`	`1299`	`}`
`1300`	`1300`
`1301`	`1301`	`private static long mapToLong(Value value) throws SQLException {`
`@@ -1305,7 +1305,7 @@ private static long mapToLong(Value value) throws SQLException {`
`1305`	`1305`	`if (Type.NULL.isTypeOf(value)) {`
`1306`	`1306`	`return 0L;`
`1307`	`1307`	`}`
`1308`		`- throw new SQLException(String.format("%s value can not be mapped to long.", value.type()));`
	`1308`	`+ throw new SQLException(String.format("%s value can not be mapped to long", value.type()));`
`1309`	`1309`	`}`
`1310`	`1310`
`1311`	`1311`	`private static float mapToFloat(Value value) throws SQLException {`
`@@ -1315,12 +1315,12 @@ private static float mapToFloat(Value value) throws SQLException {`
`1315`	`1315`	`if (Double.compare(doubleValue, floatValue) == 0) {`
`1316`	`1316`	`return floatValue;`
`1317`	`1317`	`}`
`1318`		`- throw new SQLException("The number is out of float range.");`
	`1318`	`+ throw new SQLException("The number is out of float range");`
`1319`	`1319`	`}`
`1320`	`1320`	`if (Type.NULL.isTypeOf(value)) {`
`1321`	`1321`	`return 0.0f;`
`1322`	`1322`	`}`
`1323`		`- throw new SQLException(String.format("%s value can not be mapped to float.", value.type()));`
	`1323`	`+ throw new SQLException(String.format("%s value can not be mapped to float", value.type()));`
`1324`	`1324`	`}`
`1325`	`1325`
`1326`	`1326`	`private static double mapToDouble(Value value) throws SQLException {`
`@@ -1330,7 +1330,7 @@ private static double mapToDouble(Value value) throws SQLException {`
`1330`	`1330`	`if (Type.NULL.isTypeOf(value)) {`
`1331`	`1331`	`return 0.0;`
`1332`	`1332`	`}`
`1333`		`- throw new SQLException(String.format("%s value can not be mapped to double.", value.type()));`
	`1333`	`+ throw new SQLException(String.format("%s value can not be mapped to double", value.type()));`
`1334`	`1334`	`}`
`1335`	`1335`
`1336`	`1336`	`private static byte[] mapToBytes(Value value, int maxFieldSize) throws SQLException {`
`@@ -1340,7 +1340,7 @@ private static byte[] mapToBytes(Value value, int maxFieldSize) throws SQLExcept`
`1340`	`1340`	`if (Type.BYTES.isTypeOf(value)) {`
`1341`	`1341`	`return truncate(value.asByteArray(), maxFieldSize);`
`1342`	`1342`	`}`
`1343`		`- throw new SQLException(String.format("%s value can not be mapped to byte array.", value.type()));`
	`1343`	`+ throw new SQLException(String.format("%s value can not be mapped to byte array", value.type()));`
`1344`	`1344`	`}`
`1345`	`1345`
`1346`	`1346`	`private static Reader mapToReader(Value value, int maxFieldSize) throws SQLException {`
`@@ -1350,7 +1350,7 @@ private static Reader mapToReader(Value value, int maxFieldSize) throws SQLExcep`
`1350`	`1350`	`if (Type.NULL.isTypeOf(value)) {`
`1351`	`1351`	`return null;`
`1352`	`1352`	`}`
`1353`		`- throw new SQLException(String.format("%s value can not be mapped to Reader.", value.type()));`
	`1353`	`+ throw new SQLException(String.format("%s value can not be mapped to Reader", value.type()));`
`1354`	`1354`	`}`
`1355`	`1355`
`1356`	`1356`	`@SuppressWarnings("BigDecimalMethodWithoutRoundingCalled")`
`@@ -1361,7 +1361,8 @@ private static BigDecimal mapToBigDecimal(Value value, Integer scale) throws SQL`
`1361`	`1361`	`case INTEGER -> BigDecimal.valueOf(value.asLong());`
`1362`	`1362`	`case FLOAT -> BigDecimal.valueOf(value.asDouble());`
`1363`	`1363`	`case NULL -> null;`
`1364`		`- default -> throw new SQLException(String.format("%s value can not be mapped to BigDecimal.", value.type()));`
	`1364`	`+ default -> throw new SQLException(`
	`1365`	`+ String.format("%s value can not be mapped to java.math.BigDecimal", value.type()));`
`1365`	`1366`	`};`
`1366`	`1367`
`1367`	`1368`	`if (result != null && scale != null) {`
`@@ -1383,7 +1384,7 @@ private static InputStream mapToAsciiStream(Value value, int maxFieldSize) throw`
`1383`	`1384`	`if (Type.NULL.isTypeOf(value)) {`
`1384`	`1385`	`return null;`
`1385`	`1386`	`}`
`1386`		`- throw new SQLException(String.format("%s value can not be mapped to InputStream.", value.type()));`
	`1387`	`+ throw new SQLException(String.format("%s value can not be mapped to java.io.InputStream", value.type()));`
`1387`	`1388`	`}`
`1388`	`1389`
`1389`	`1390`	`private static InputStream mapToBinaryStream(Value value, int maxFieldSize) throws SQLException {`
`@@ -1393,7 +1394,7 @@ private static InputStream mapToBinaryStream(Value value, int maxFieldSize) thro`
`1393`	`1394`	`if (Type.NULL.isTypeOf(value)) {`
`1394`	`1395`	`return null;`
`1395`	`1396`	`}`
`1396`		`- throw new SQLException(String.format("%s value can not be mapped to InputStream.", value.type()));`
	`1397`	`+ throw new SQLException(String.format("%s value can not be mapped to java.io.InputStream", value.type()));`
`1397`	`1398`	`}`
`1398`	`1399`
`1399`	`1400`	`private static Object mapToObject(Value value, int maxFieldSize) {`
Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,7 @@ public <T> T unwrap(Class<T> iface) throws SQLException {`
`251`	`251`	`return iface.cast(this);`
`252`	`252`	`}`
`253`	`253`	`else {`
`254`		`- throw new SQLException("This object does not implement the given interface.");`
	`254`	`+ throw new SQLException("This object does not implement the given interface");`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`