diff --git a/README.md b/README.md index ac7a6d12..f0110c10 100644 --- a/README.md +++ b/README.md @@ -152,7 +152,8 @@ class RestaurantDemoSpec extends Specification with RestaurantDemoDatabaseFuncti ## Run Tests ```shell docker rm -f mongodb; -docker run -d --publish 27017:27017 --name mongodb mongocamp/mongodb:latest; +docker run -d --publish 27017:27017 --name mongodb mongocamp/mongodb:latest; +sbt test ``` ## Supporters diff --git a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSet.scala b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSet.scala index 62ad2d6a..a7b9379a 100644 --- a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSet.scala +++ b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSet.scala @@ -251,7 +251,7 @@ class MongoDbResultSet(collectionDao: MongoDAO[Document], data: List[Document], override def getMetaData: ResultSetMetaData = { checkClosed() - new MongoDbResultSetMetaData(collectionDao, data) + new MongoDbResultSetMetaData(collectionDao, data, keySet) } override def getObject(columnIndex: Int): AnyRef = { diff --git a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSetMetaData.scala b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSetMetaData.scala index 85e35c3b..a70b7719 100644 --- a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSetMetaData.scala +++ b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSetMetaData.scala @@ -54,6 +54,17 @@ class MongoDbResultSetMetaData extends ResultSetMetaData { override def getColumnCount: Int = document.size + override def getColumnLabel(column: Int): String = { + val keys: Iterable[String] = if (keySet.nonEmpty) { + keySet + } else { + document.keys + } + keys.toList(column - 1) + } + + override def getColumnName(column: Int): String = getColumnLabel(column) + override def isAutoIncrement(column: Int): Boolean = false override def isCaseSensitive(column: Int): Boolean = true @@ -68,17 +79,6 @@ class MongoDbResultSetMetaData extends ResultSetMetaData { override def getColumnDisplaySize(column: Int): Int = Int.MaxValue - override def getColumnLabel(column: Int): String = { - val keys : Iterable[String] =if (keySet.nonEmpty) { - keySet - } else { - document.keys - } - keys.toList(column - 1) - } - - override def getColumnName(column: Int): String = getColumnLabel(column) - override def getSchemaName(column: Int): String = collectionDao.databaseName override def getPrecision(column: Int): Int = 0 @@ -90,7 +90,7 @@ class MongoDbResultSetMetaData extends ResultSetMetaData { override def getCatalogName(column: Int): String = collectionDao.name override def getColumnType(column: Int): Int = { - document.values.toList(column - 1) match { + document(getColumnLabel(column)) match { case _: BsonInt32 => java.sql.Types.INTEGER case _: BsonInt64 => java.sql.Types.BIGINT case _: BsonNumber => java.sql.Types.DOUBLE @@ -136,6 +136,11 @@ class MongoDbResultSetMetaData extends ResultSetMetaData { override def isWrapperFor(iface: Class[_]): Boolean = false def getColumnIndex(columnLabel: String): Int = { - document.keys.toList.indexOf(columnLabel) + val keys: List[String] = if (keySet.nonEmpty) { + keySet + } else { + document.keys.toList + } + keys.indexOf(columnLabel) + 1 } } diff --git a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala index 1a8344b5..b4235458 100644 --- a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala +++ b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala @@ -7,7 +7,6 @@ import dev.mongocamp.driver.mongodb.jdbc.{MongoJdbcCloseable, MongoJdbcConnectio import dev.mongocamp.driver.mongodb.json.JsonConverter import dev.mongocamp.driver.mongodb.sql.MongoSqlQueryHolder import dev.mongocamp.driver.mongodb.{Converter, GenericObservable} -import jdk.graal.compiler.util.json.JsonParser import org.joda.time.DateTime import java.io.{InputStream, Reader} @@ -224,9 +223,9 @@ case class MongoPreparedStatement(connection: MongoJdbcConnection) extends Calla case t: Time => parameters.put(parameterIndex, s"'${t.toInstant.toString}'") case a: Array[Byte] => - parameters.put(parameterIndex, a.mkString("[", ",", "]")) + parameters.put(parameterIndex, new JsonConverter().toJson(a)) case a: Iterable[_] => - parameters.put(parameterIndex, a.mkString("[", ",", "]")) + parameters.put(parameterIndex, new JsonConverter().toJson(a)) case _ => parameters.put(parameterIndex, x.toString) } diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetMetaDataSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetMetaDataSuite.scala new file mode 100644 index 00000000..e4ed75ac --- /dev/null +++ b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetMetaDataSuite.scala @@ -0,0 +1,130 @@ +package dev.mongocamp.driver.mongodb.jdbc + +import dev.mongocamp.driver.mongodb.MongoDAO +import dev.mongocamp.driver.mongodb.jdbc.resultSet.MongoDbResultSetMetaData +import dev.mongocamp.driver.mongodb.jdbc.statement.MongoPreparedStatement +import munit.FunSuite +import org.mongodb.scala.Document + +import java.sql.ResultSetMetaData + +class MongoDbResultSetMetaDataSuite extends BaseJdbcSuite { + + var metaData: ResultSetMetaData = _ + + override def beforeAll(): Unit = { + super.beforeAll() + val preparedStatement2 = MongoPreparedStatement(connection.asInstanceOf[MongoJdbcConnection]) + preparedStatement2.executeUpdate("drop table testCollection") + preparedStatement2.executeUpdate("insert into testCollection (intField, stringField, booleanField) values (1, 'test', true)") + preparedStatement2.executeUpdate("insert into testCollection (intField, stringField, booleanField) values (2, 'test2', false)") + metaData = preparedStatement2.executeQuery("select intField, booleanField, stringField from testCollection").getMetaData + } + + test("getColumnCount should return the correct column count") { + assertEquals(metaData.getColumnCount, 3) + } + + test("getColumnLabel should return the correct column label") { + assertEquals(metaData.getColumnLabel(1), "intField") + assertEquals(metaData.getColumnLabel(2), "booleanField") + assertEquals(metaData.getColumnLabel(3), "stringField") + } + + test("getColumnName should return the correct column name") { + assertEquals(metaData.getColumnName(1), "intField") + } + + test("isAutoIncrement should return false") { + assert(!metaData.isAutoIncrement(1)) + } + + test("isCaseSensitive should return true") { + assert(metaData.isCaseSensitive(1)) + } + + test("isSearchable should return true") { + assert(metaData.isSearchable(1)) + } + + test("isCurrency should return false") { + assert(!metaData.isCurrency(1)) + } + + test("isNullable should return columnNullable") { + assertEquals(metaData.isNullable(1), java.sql.ResultSetMetaData.columnNullable) + } + + test("isSigned should return false") { + assert(!metaData.isSigned(1)) + } + + test("getColumnDisplaySize should return Int.MaxValue") { + assertEquals(metaData.getColumnDisplaySize(1), Int.MaxValue) + } + + test("getSchemaName should return the database name") { + assertEquals(metaData.getSchemaName(1), "mongocamp-unit-test") + } + + test("getPrecision should return 0") { + assertEquals(metaData.getPrecision(1), 0) + } + + test("getScale should return 0") { + assertEquals(metaData.getScale(1), 0) + } + + test("getTableName should return the collection name") { + assertEquals(metaData.getTableName(1), "testCollection") + } + + test("getCatalogName should return the collection name") { + assertEquals(metaData.getCatalogName(1), "testCollection") + } + + test("getColumnType should return the correct SQL type") { + assertEquals(metaData.getColumnType(1), java.sql.Types.BIGINT) + assertEquals(metaData.getColumnType(2), java.sql.Types.BOOLEAN) + assertEquals(metaData.getColumnType(3), java.sql.Types.VARCHAR) + } + + test("getColumnTypeName should return the correct SQL type name") { + assertEquals(metaData.getColumnTypeName(1), "BIGINT") + assertEquals(metaData.getColumnTypeName(2), "BOOLEAN") + assertEquals(metaData.getColumnTypeName(3), "VARCHAR") + } + + test("isReadOnly should return false") { + assert(!metaData.isReadOnly(1)) + } + + test("isWritable should return true") { + assert(metaData.isWritable(1)) + } + + test("isDefinitelyWritable should return true") { + assert(metaData.isDefinitelyWritable(1)) + } + + test("getColumnClassName should return the correct class name") { + assertEquals(metaData.getColumnClassName(1), classOf[java.lang.Long].getName) + assertEquals(metaData.getColumnClassName(2), classOf[java.lang.Boolean].getName) + assertEquals(metaData.getColumnClassName(3), classOf[java.lang.String].getName) + } + + test("unwrap should return null") { + assertEquals(metaData.unwrap(classOf[Object]), null) + } + + test("isWrapperFor should return false") { + assert(!metaData.isWrapperFor(classOf[Object])) + } + + test("getColumnIndex should return the correct index") { + val metaData2 = metaData.asInstanceOf[MongoDbResultSetMetaData] + assertEquals(metaData2.getColumnIndex("intField"), 1) + assertEquals(metaData2.getColumnIndex("booleanField"), 2) + assertEquals(metaData2.getColumnIndex("stringField"), 3) + } +} diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala index f1729ff9..2aa289ef 100644 --- a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala +++ b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala @@ -6,12 +6,11 @@ import org.joda.time.DateTime import org.mongodb.scala.bson.collection.immutable.Document import org.mongodb.scala.model.Updates -import java.sql.{Date, ResultSet, SQLFeatureNotSupportedException, Time, Timestamp} +import java.sql.* class MongoDbResultSetSuite extends BaseJdbcSuite { - + def initializeResultSet(): ResultSet = { - super.beforeAll() val data = List( Document("id" -> 1, "name" -> "test_name", "active" -> true, "date" -> new DateTime("2021-01-01T00:00:00Z").toDate), Document("id" -> 2, "name" -> "another_name", "active" -> false) @@ -52,12 +51,43 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { assertEquals(resultSet.getInt("id"), 1) } + test("getByte() should return the correct value") { + val resultSet = initializeResultSet() + resultSet.next() + assertEquals(resultSet.getByte("id"), 1.toByte) + } + + test("getBytes() should return the correct value") { + val resultSet = initializeResultSet() + resultSet.next() + assertEquals(resultSet.getByte("id"), 1.toByte) + } + + test("getShort() should return the correct value") { + val resultSet = initializeResultSet() + resultSet.next() + assertEquals(resultSet.getShort("id"), 1.toShort) + } + + test("getFloat() should return the correct value") { + val resultSet = initializeResultSet() + resultSet.next() + assertEquals(resultSet.getFloat("id"), 1.toFloat) + } + test("getDouble() should return the correct value") { val resultSet = initializeResultSet() resultSet.next() assertEquals(resultSet.getDouble("id"), 1.0) } + test("getBigDecimal() should return the correct value") { + val resultSet = initializeResultSet() + resultSet.next() + assertEquals(resultSet.getBigDecimal("id"), new java.math.BigDecimal(1)) + assertEquals(resultSet.getBigDecimal("id", 1), new java.math.BigDecimal(1).setScale(1)) + } + test("getDate() should return the correct value") { val resultSet = initializeResultSet() resultSet.next() @@ -195,7 +225,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { test("findColumn() should return the correct column index") { val resultSet = initializeResultSet() - assertEquals(resultSet.findColumn("id"), 0) + assertEquals(resultSet.findColumn("id"), 1) } test("getWarnings() should return null") { @@ -227,7 +257,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { val resultSet = initializeResultSet() assert(!resultSet.isWrapperFor(classOf[MongoDbResultSet])) } - + test("updateNull should update the value to null") { val resultSet = initializeResultSet() resultSet.next() @@ -246,14 +276,28 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { val resultSet = initializeResultSet() resultSet.next() resultSet.updateInt(1, 42) - assert(resultSet.getInt(1) == 42) + assertEquals(resultSet.getInt(1), 42) + } + + test("updateFloat should update the value") { + val resultSet = initializeResultSet() + resultSet.next() + resultSet.updateFloat(1, 42.toFloat) + assertEquals(resultSet.getFloat(1), 42.toFloat) + } + + test("updateBigDecimal should update the value") { + val resultSet = initializeResultSet() + resultSet.next() + resultSet.updateBigDecimal(1, new java.math.BigDecimal(42)) + assertEquals(resultSet.getBigDecimal(1), new java.math.BigDecimal(42)) } test("updateString should update the value") { val resultSet = initializeResultSet() resultSet.next() resultSet.updateString(2, "updated_name") - assert(resultSet.getString(2) == "updated_name") + assertEquals(resultSet.getString(2), "updated_name") } test("updateDate should update the value") { @@ -261,7 +305,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { resultSet.next() val newDate = new Date(1622505600000L) resultSet.updateDate(4, newDate) - assert(resultSet.getDate(4) == newDate) + assertEquals(resultSet.getDate(4), newDate) } test("updateTime should update the value") { @@ -269,7 +313,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { resultSet.next() val newTime = new Time(1622505600000L) resultSet.updateTime(4, newTime) - assert(resultSet.getTime(4) == newTime) + assertEquals(resultSet.getTime(4), newTime) } test("updateTimestamp should update the value") { @@ -277,7 +321,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { resultSet.next() val newTimestamp = new Timestamp(1622505600000L) resultSet.updateTimestamp(4, newTimestamp) - assert(resultSet.getTimestamp(4) == newTimestamp) + assertEquals(resultSet.getTimestamp(4), newTimestamp) } test("updateObject should update the value") { @@ -304,8 +348,24 @@ class MongoDbResultSetSuite extends BaseJdbcSuite { test("getConcurrency should throw SQLFeatureNotSupportedException") { val resultSet = initializeResultSet() - intercept[SQLFeatureNotSupportedException] { - resultSet.getConcurrency - } + intercept[SQLFeatureNotSupportedException] (resultSet.getConcurrency) + intercept[SQLFeatureNotSupportedException] (resultSet.updateAsciiStream(99, null, 1)) + intercept[SQLFeatureNotSupportedException] (resultSet.updateAsciiStream("updateAsciiStream", null, 1)) + intercept[SQLFeatureNotSupportedException] (resultSet.updateBinaryStream(99, null, 1)) + intercept[SQLFeatureNotSupportedException] (resultSet.updateBinaryStream("updateBinaryStream", null, 1)) + intercept[SQLFeatureNotSupportedException] (resultSet.updateCharacterStream(99, null, 1)) + intercept[SQLFeatureNotSupportedException] (resultSet.updateCharacterStream("updateCharacterStream", null, 1)) + } + + test("null values for not implemented get methods") { + val resultSet = initializeResultSet() + assertEquals(resultSet.getAsciiStream(1), null) + assertEquals(resultSet.getUnicodeStream(1), null) + assertEquals(resultSet.getBinaryStream(1), null) + assertEquals(resultSet.getAsciiStream("id"), null) + assertEquals(resultSet.getUnicodeStream("id"), null) + assertEquals(resultSet.getBinaryStream("id"), null) + } + } diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoPreparedStatementSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoPreparedStatementSuite.scala index be8a8f84..3ee5ba19 100644 --- a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoPreparedStatementSuite.scala +++ b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoPreparedStatementSuite.scala @@ -1,8 +1,11 @@ package dev.mongocamp.driver.mongodb.jdbc import dev.mongocamp.driver.mongodb.jdbc.statement.MongoPreparedStatement -import scala.collection.convert._ + +import java.io.{InputStream, Reader} +import java.net.URL import java.sql.{Date, Time, Timestamp} +import java.util.Calendar class MongoPreparedStatementSuite extends BaseJdbcSuite { var preparedStatement: MongoPreparedStatement = _ @@ -80,7 +83,7 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { } test("setBytes should set byte array parameter") { - val bytes = Array[Byte](1, 2, 3) + val bytes = Array[Byte](1.toByte, 2.toByte, 3.toByte) preparedStatement.setBytes(1, bytes) assertEquals(preparedStatement.getBytes(1).toList, bytes.toList) } @@ -94,19 +97,19 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { test("setTime should set time parameter") { val time = new Time(System.currentTimeMillis()) preparedStatement.setTime(1, time) - assertEquals(preparedStatement.getTime(1) , time) + assertEquals(preparedStatement.getTime(1), time) } test("setTimestamp should set timestamp parameter") { val timestamp = new Timestamp(System.currentTimeMillis()) preparedStatement.setTimestamp(1, timestamp) - assertEquals(preparedStatement.getTimestamp(1) , timestamp) + assertEquals(preparedStatement.getTimestamp(1), timestamp) } test("clearParameters should clear all parameters") { preparedStatement.setString(1, "test") preparedStatement.clearParameters() - assertEquals(preparedStatement.getString(1) , null) + assertEquals(preparedStatement.getString(1), null) } test("getConnection should return the connection") { @@ -114,16 +117,16 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { } test("getQueryTimeout should return the query timeout") { - assertEquals(preparedStatement.getQueryTimeout , 10) + assertEquals(preparedStatement.getQueryTimeout, 10) } test("setQueryTimeout should set the query timeout") { preparedStatement.setQueryTimeout(20) - assertEquals(preparedStatement.getQueryTimeout , 20) + assertEquals(preparedStatement.getQueryTimeout, 20) } test("getWarnings should return null") { - assertEquals(preparedStatement.getWarnings , null) + assertEquals(preparedStatement.getWarnings, null) } test("clearWarnings should not throw exception") { @@ -131,17 +134,19 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { } test("getResultSet should return the last result set") { - assertNotEquals(preparedStatement.getResultSet , null) + assertNotEquals(preparedStatement.getResultSet, null) } test("getUpdateCount should return the last update count") { - assertEquals(preparedStatement.getUpdateCount , -1) - preparedStatement.executeUpdate("INSERT INTO table_name (column1, column2, column3) VALUES ('value1', 123, '2022-01-01T00:00:00.000Z'), ('value2', 456, '2022-02-01T00:00:00.000Z');") - assertEquals(preparedStatement.getUpdateCount , 2) + assertEquals(preparedStatement.getUpdateCount, -1) + preparedStatement.executeUpdate( + "INSERT INTO table_name (column1, column2, column3) VALUES ('value1', 123, '2022-01-01T00:00:00.000Z'), ('value2', 456, '2022-02-01T00:00:00.000Z');" + ) + assertEquals(preparedStatement.getUpdateCount, 2) preparedStatement.executeUpdate("Update table_name SET column1 = 'value3' WHERE column2 = 123;") - assertEquals(preparedStatement.getUpdateCount , 1) + assertEquals(preparedStatement.getUpdateCount, 1) preparedStatement.executeUpdate("DELETE FROM table_name WHERE column2 = 123;") - assertEquals(preparedStatement.getUpdateCount , 1) + assertEquals(preparedStatement.getUpdateCount, 1) } test("getMoreResults should return false") { @@ -149,23 +154,23 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { } test("getFetchDirection should return FETCH_FORWARD") { - assertEquals(preparedStatement.getFetchDirection , java.sql.ResultSet.FETCH_FORWARD) + assertEquals(preparedStatement.getFetchDirection, java.sql.ResultSet.FETCH_FORWARD) } test("getFetchSize should return -1") { - assertEquals(preparedStatement.getFetchSize , -1) + assertEquals(preparedStatement.getFetchSize, -1) } test("getResultSetType should return TYPE_FORWARD_ONLY") { - assertEquals(preparedStatement.getResultSetType , java.sql.ResultSet.TYPE_FORWARD_ONLY) + assertEquals(preparedStatement.getResultSetType, java.sql.ResultSet.TYPE_FORWARD_ONLY) } test("getGeneratedKeys should return null") { - assertEquals(preparedStatement.getGeneratedKeys , null) + assertEquals(preparedStatement.getGeneratedKeys, null) } test("getResultSetHoldability should return 0") { - assertEquals(preparedStatement.getResultSetHoldability , 0) + assertEquals(preparedStatement.getResultSetHoldability, 0) } test("isPoolable should return false") { @@ -182,18 +187,33 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { test("getObject should return the parameter value") { preparedStatement.setString(1, "test") - assertEquals(preparedStatement.getObject(1) , "test") + assertEquals(preparedStatement.getObject(1), "test") } test("getURL should return the URL parameter") { preparedStatement.setString(1, "http://example.com") - assertEquals(preparedStatement.getURL(1) , new java.net.URL("http://example.com")) + assertEquals(preparedStatement.getURL(1), new java.net.URL("http://example.com")) + } + + test("setObject should return an string") { + preparedStatement.setObject(1, "value") + assertEquals(preparedStatement.getString(1), "value") + preparedStatement.setObject(1, "value1", java.sql.Types.VARCHAR) + assertEquals(preparedStatement.getString(1), "value1") + preparedStatement.setObject(1, "value2", java.sql.Types.VARCHAR, 0) + assertEquals(preparedStatement.getString(1), "value2") + preparedStatement.setObject(1, null) + assertEquals(preparedStatement.getString(1), "null") + preparedStatement.setObject(1, List(1, 2, 3)) + assertEquals(preparedStatement.getString(1), "[1,2,3]") + preparedStatement.setObject(1, List("hallo", "world")) + assertEquals(preparedStatement.getString(1), "[\"hallo\",\"world\"]") } test("set URL should set the URL parameter") { preparedStatement.setURL(1, new java.net.URL("http://example.com")) - assertEquals(preparedStatement.getURL(1) , new java.net.URL("http://example.com")) - assertEquals(preparedStatement.getString(1) , "http://example.com") + assertEquals(preparedStatement.getURL(1), new java.net.URL("http://example.com")) + assertEquals(preparedStatement.getString(1), "http://example.com") } import java.sql.SQLFeatureNotSupportedException @@ -287,5 +307,44 @@ class MongoPreparedStatementSuite extends BaseJdbcSuite { assertThrowsFeatureNotSupportedException(preparedStatement.setTime("param", null, null)) assertThrowsFeatureNotSupportedException(preparedStatement.setTimestamp("param", null, null)) assertThrowsFeatureNotSupportedException(preparedStatement.setNull("param", 0, null)) + assertThrowsFeatureNotSupportedException(preparedStatement.setClob("param", null.asInstanceOf[Reader])) + assertThrowsFeatureNotSupportedException(preparedStatement.setNClob("param", null.asInstanceOf[Reader])) + assertThrowsFeatureNotSupportedException(preparedStatement.setBlob("param", null.asInstanceOf[InputStream])) + } + + test("set values should not throw exception") { + preparedStatement.addBatch() + preparedStatement.setCharacterStream(1, null, 0) + preparedStatement.setRef(1, null) + preparedStatement.setBlob(1, null.asInstanceOf[java.sql.Blob]) + preparedStatement.setClob(1, null.asInstanceOf[java.sql.Clob]) + preparedStatement.setDate(1, new Date(0), Calendar.getInstance()) + preparedStatement.setTime(1, new Time(0), Calendar.getInstance()) + preparedStatement.setTimestamp(1, new Timestamp(0), Calendar.getInstance()) + preparedStatement.setNull(1, 0, "typeName") + preparedStatement.setURL(1, new URL("http://example.com")) + preparedStatement.setRowId(1, null) + preparedStatement.setNString(1, null) + preparedStatement.setNCharacterStream(1, null, 0L) + preparedStatement.setNClob(1, null.asInstanceOf[java.sql.NClob]) + preparedStatement.setClob(1, null, 0L) + preparedStatement.setBlob(1, null, 0L) + preparedStatement.setNClob(1, null, 0L) + preparedStatement.setSQLXML(1, null) + preparedStatement.setAsciiStream(1, null, 0L) + preparedStatement.setBinaryStream(1, null, 0L) + preparedStatement.setCharacterStream(1, null, 0L) + preparedStatement.setAsciiStream(1, null) + preparedStatement.setBinaryStream(1, null) + preparedStatement.setCharacterStream(1, null) + preparedStatement.setNCharacterStream(1, null) + preparedStatement.setClob(1, null.asInstanceOf[java.sql.Clob]) + preparedStatement.setBlob(1, null.asInstanceOf[java.sql.Blob]) + preparedStatement.setNClob(1, null.asInstanceOf[java.sql.NClob]) + preparedStatement.setArray(1, null.asInstanceOf[java.sql.Array]) + preparedStatement.setAsciiStream(1, null.asInstanceOf[InputStream], 1) + preparedStatement.setUnicodeStream(1, null.asInstanceOf[InputStream], 1) + preparedStatement.setBinaryStream(1, null.asInstanceOf[InputStream], 1) + assertEquals(preparedStatement.getMetaData, null) } }