dev

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>com.microsoft.sqlserver</groupId>
 	<artifactId>mssql-jdbc</artifactId>
-	<version>6.4.0.${jreVersion}</version>
+	<version>6.5.0-SNAPSHOT.${jreVersion}-preview</version>
 	<packaging>jar</packaging>
 
 	<name>Microsoft JDBC Driver for SQL Server</name>
@@ -40,8 +40,8 @@
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<junit.platform.version>1.0.0-M3</junit.platform.version>
-		<junit.jupiter.version>5.0.0-M3</junit.jupiter.version>
+		<junit.platform.version>1.1.0</junit.platform.version>
+		<junit.jupiter.version>5.1.0</junit.jupiter.version>
 	</properties>
 
 	<dependencies>
@@ -118,13 +118,13 @@
 		<dependency>
 			<groupId>com.zaxxer</groupId>
 			<artifactId>HikariCP</artifactId>
-			<version>2.7.4</version>
+			<version>2.7.8</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
 			<artifactId>commons-dbcp2 </artifactId>
-			<version>2.1.1</version>
+			<version>2.2.0</version>
 			<scope>test</scope>
 		</dependency>
   	<!-- 

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java

@@ -232,10 +232,23 @@ public byte[] getBytes(long pos,
      */
     public long length() throws SQLException {
         checkClosed();
+        if (value == null && activeStreams.get(0) instanceof PLPInputStream) {
+        	return (long)((PLPInputStream)activeStreams.get(0)).payloadLength;
+        }
         getBytesFromStream();
         return value.length;
     }
 
+    /**
+     * Function for the result set to maintain blobs it has created
+     * @throws SQLException
+     */
+    void fillByteArray() throws SQLException {
+    	if(!isClosed) {
+    		getBytesFromStream();
+    	}
+    }
+
     /**
      * Converts stream to byte[]
      * @throws SQLServerException

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java

@@ -1450,6 +1450,8 @@ public NClob getNClob(String parameterName) throws SQLException {
         int l = 0;
         if (paramNames != null)
             l = paramNames.size();
+        if (l == 0)//Server didn't return anything, user might not have access
+        	return 1;//attempting to look up the first column will return no access exception
 
         // handle `@name` as well as `name`, since `@name` is what's returned 
         // by DatabaseMetaData#getProcedureColumns

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java

@@ -126,6 +126,7 @@ final void setCurrentRowType(RowType rowType) {
      * occurs
      */
     private Closeable activeStream;
+    private Blob activeBlob;
 
     /**
      * A window of fetchSize quickly accessible rows for scrollable result sets
@@ -669,6 +670,7 @@ final Column getColumn(int columnIndex) throws SQLServerException {
         // before moving to another one.
         if (null != activeStream) {
             try {
+            	fillBlobs();
                 activeStream.close();
             }
             catch (IOException e) {
@@ -747,6 +749,7 @@ private Column loadColumn(int index) throws SQLServerException {
     /* ----------------- JDBC API methods ------------------ */
 
     private void moverInit() throws SQLServerException {
+    	fillBlobs();
         cancelInsert();
         cancelUpdates();
     }
@@ -1035,6 +1038,7 @@ public boolean next() throws SQLServerException {
     public boolean wasNull() throws SQLServerException {
         loggerExternal.entering(getClassNameLogging(), "wasNull");
         checkClosed();
+        fillBlobs();
         loggerExternal.exiting(getClassNameLogging(), "wasNull", lastValueWasNull);
         return lastValueWasNull;
     }
@@ -1892,6 +1896,7 @@ Column getterGetColumn(int index) throws SQLServerException {
         if (logger.isLoggable(java.util.logging.Level.FINER))
             logger.finer(toString() + " Getting Column:" + index);
 
+        fillBlobs();
         return loadColumn(index);
     }
 
@@ -2657,6 +2662,7 @@ public Blob getBlob(int i) throws SQLServerException {
         checkClosed();
         Blob value = (Blob) getValue(i, JDBCType.BLOB);
         loggerExternal.exiting(getClassNameLogging(), "getBlob", value);
+        activeBlob = value;
         return value;
     }
 
@@ -2665,6 +2671,7 @@ public Blob getBlob(String colName) throws SQLServerException {
         checkClosed();
         Blob value = (Blob) getValue(findColumn(colName), JDBCType.BLOB);
         loggerExternal.exiting(getClassNameLogging(), "getBlob", value);
+        activeBlob = value;
         return value;
     }
 
@@ -6507,6 +6514,24 @@ final void doServerFetch(int fetchType,
             scrollWindow.reset();
         }
     }
+
+    /*
+     * Iterates through the list of objects which rely on the stream that's about to be closed, filling them with their data
+     * Will skip over closed blobs, implemented in SQLServerBlob
+     */
+    private void fillBlobs() {
+    	if (null != activeBlob && activeBlob instanceof SQLServerBlob) {
+    		try {
+    			((SQLServerBlob)activeBlob).fillByteArray();
+    		} catch (SQLException e) {
+    			if (logger.isLoggable(java.util.logging.Level.FINER)) {
+    				logger.finer(toString() + "Filling blobs before closing: " + e.getMessage());
+    			}
+    		} finally {
+    			activeBlob = null;
+    		}
+    	}
+	}
 
     /**
      * Discards the contents of the current fetch buffer.
@@ -6519,6 +6544,9 @@ final void doServerFetch(int fetchType,
      * fetch buffer is considered to be discarded.
      */
     private void discardFetchBuffer() {
+    	//fills blobs before discarding anything
+    	fillBlobs();
+
         // Clear the TDSReader mark at the start of the fetch buffer
         fetchBuffer.clearStartMark();
 

src/test/java/com/microsoft/sqlserver/jdbc/unit/lobs/lobsTest.java

@@ -221,6 +221,59 @@ else if (lobClass == Blob.class)
         }
     }
 
+    @Test
+    @DisplayName("testFreedBlobs")
+    private void testFreedBlobs(Class lobClass,
+            boolean isResultSet) throws SQLException {
+        String types[] = {"varbinary(max)"};
+        try {
+        	table = createTable(table, types, false);  // create empty table
+            int size = 10000;
+
+            byte[] data = new byte[size];
+            ThreadLocalRandom.current().nextBytes(data);
+
+            Blob blob = null;
+            InputStream stream = null;
+            for (int i = 0; i < 5; i++)
+            {
+                PreparedStatement ps = conn.prepareStatement("INSERT INTO " + table.getEscapedTableName() + "  VALUES(?)");
+                blob = conn.createBlob();
+                blob.setBytes(1, data);
+                ps.setBlob(1, blob);
+                ps.executeUpdate();
+            }
+
+            byte[] chunk = new byte[size];
+            ResultSet rs = stmt.executeQuery("select * from " + table.getEscapedTableName());
+            for (int i = 0; i < 5; i++)
+            {
+                rs.next();
+
+                blob = rs.getBlob(1);
+                stream = blob.getBinaryStream();
+                while (stream.available() > 0)
+                	stream.read();
+                blob.free();
+                try {
+                	stream = blob.getBinaryStream();
+                } catch (SQLException e) {
+                    assertTrue(e.getMessage().contains("This Blob object has been freed."));
+                }
+            }
+            rs.close();
+            try {
+            	stream = blob.getBinaryStream();
+            } catch (SQLException e) {
+                assertTrue(e.getMessage().contains("This Blob object has been freed."));
+            }
+        }
+        catch (Exception e) {
+            this.dropTables(table);
+            e.printStackTrace();
+        }
+    }
+
     @Test
     @DisplayName("testMultipleCloseCharacterStream")
     public void testMultipleCloseCharacterStream() throws Exception {
@@ -413,6 +466,92 @@ public void testUpdatorClob() throws Exception {
         String types[] = {"varchar(max)"};
         testUpdateLobs(types, Clob.class);
     }
+
+    @Test
+    @DisplayName("readBlobStreamAfterClosingRS") 
+    public void readBlobStreamAfterClosingRS() throws Exception {
+        String types[] = {"varbinary(max)"};
+        table = createTable(table, types, false);  // create empty table
+        int size = 10000;
+
+        byte[] data = new byte[size];
+        ThreadLocalRandom.current().nextBytes(data);
+
+        Blob blob = null;
+        InputStream stream = null;
+        PreparedStatement ps = conn.prepareStatement("INSERT INTO " + table.getEscapedTableName() + "  VALUES(?)");
+        blob = conn.createBlob();
+        blob.setBytes(1, data);
+        ps.setBlob(1, blob);
+        ps.executeUpdate();
+
+        byte[] chunk = new byte[size];
+        ResultSet rs = stmt.executeQuery("select * from " + table.getEscapedTableName());
+        rs.next();
+
+        blob = rs.getBlob(1);
+        stream = blob.getBinaryStream();
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        int read = 0;
+        while ((read = stream.read(chunk)) > 0)
+            buffer.write(chunk, 0, read);
+        assertEquals(chunk.length, size);
+        rs.close();
+        stream = blob.getBinaryStream();
+        buffer = new ByteArrayOutputStream();
+        read = 0;
+        while ((read = stream.read(chunk)) > 0)
+            buffer.write(chunk, 0, read);
+        assertEquals(chunk.length, size);
+
+        if (null != blob)
+            blob.free();
+        dropTables(table);
+    }
+
+    @Test
+    @DisplayName("readMultipleBlobStreamsThenCloseRS")
+    public void readMultipleBlobStreamsThenCloseRS() throws Exception {
+    	String types[] = {"varbinary(max)"};
+    	table = createTable(table, types, false);
+    	int size = 10000;
+
+    	byte[] data = new byte[size];
+    	Blob[] blobs = {null, null, null, null, null};
+        InputStream stream = null;
+        for (int i = 0; i < 5; i++)//create 5 blobs
+        {
+            PreparedStatement ps = conn.prepareStatement("INSERT INTO " + table.getEscapedTableName() + "  VALUES(?)");
+            blobs[i] = conn.createBlob();
+            ThreadLocalRandom.current().nextBytes(data);
+            blobs[i].setBytes(1, data);
+            ps.setBlob(1, blobs[i]);
+            ps.executeUpdate();
+        }
+        byte[] chunk = new byte[size];
+        ResultSet rs = stmt.executeQuery("select * from " + table.getEscapedTableName());
+        for (int i = 0; i < 5; i++)
+        {
+        	rs.next();
+        	blobs[i] = rs.getBlob(1);
+        	stream = blobs[i].getBinaryStream();
+        	ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        	int read = 0;
+        	while ((read = stream.read(chunk)) > 0)
+        		buffer.write(chunk, 0, read);
+        	assertEquals(chunk.length, size);
+        }
+        rs.close();
+        for (int i = 0; i < 5; i++)
+        {
+        	stream = blobs[i].getBinaryStream();
+        	ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        	int read = 0;
+        	while ((read = stream.read(chunk)) > 0)
+        		buffer.write(chunk, 0, read);
+        	assertEquals(chunk.length, size);
+        }
+    }
 
     private void testUpdateLobs(String types[],
             Class lobClass) throws Exception {

src/test/java/com/microsoft/sqlserver/testframework/util/ComparisonUtil.java

@@ -92,16 +92,16 @@ public static void compareExpectedAndActual(int dataType,
         else
             switch (dataType) {
                 case java.sql.Types.BIGINT:
-                    assertTrue((((Long) expectedValue).longValue() == ((Long) actualValue).longValue()), "Unexpected bigint value");
+                    assertTrue((((Long) expectedValue).longValue() == ((Long) actualValue).longValue()), "Unexpected bigint value. Expected:" + ((Long) expectedValue).longValue() + " Actual:" + ((Long) actualValue).longValue());
                     break;
 
                 case java.sql.Types.INTEGER:
-                    assertTrue((((Integer) expectedValue).intValue() == ((Integer) actualValue).intValue()), "Unexpected int value");
+                    assertTrue((((Integer) expectedValue).intValue() == ((Integer) actualValue).intValue()), "Unexpected int value. Expected:" + ((Integer) expectedValue).intValue() + " Actual:" + ((Integer) actualValue).intValue());
                     break;
 
                 case java.sql.Types.SMALLINT:
                 case java.sql.Types.TINYINT:
-                    assertTrue((((Short) expectedValue).shortValue() == ((Short) actualValue).shortValue()), "Unexpected smallint/tinyint value");
+                    assertTrue((((Short) expectedValue).shortValue() == ((Short) actualValue).shortValue()), "Unexpected smallint/tinyint value. Expected:" + ((Short) expectedValue).shortValue() + " Actual:" + ((Short) actualValue).shortValue());
                     break;
 
                 case java.sql.Types.BIT:
@@ -115,11 +115,11 @@ public static void compareExpectedAndActual(int dataType,
                     break;
 
                 case java.sql.Types.DOUBLE:
-                    assertTrue((((Double) expectedValue).doubleValue() == ((Double) actualValue).doubleValue()), "Unexpected float value");
+                    assertTrue((((Double) expectedValue).doubleValue() == ((Double) actualValue).doubleValue()), "Unexpected double value. Expected:" + ((Double) expectedValue).doubleValue() + " Actual:" + ((Double) actualValue).doubleValue());
                     break;
 
                 case java.sql.Types.REAL:
-                    assertTrue((((Float) expectedValue).floatValue() == ((Float) actualValue).floatValue()), "Unexpected real value");
+                    assertTrue((((Float) expectedValue).floatValue() == ((Float) actualValue).floatValue()), "Unexpected real/float value. Expected:" + ((Float) expectedValue).floatValue() + " Actual:" + ((Float) actualValue).floatValue());
                     break;
 
                 case java.sql.Types.VARCHAR: