diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java
index 159e66cf2..6bf4101da 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java
@@ -125,7 +125,7 @@ final class TDS {
     // Data Classification constants
     static final byte TDS_FEATURE_EXT_DATACLASSIFICATION = 0x09;
     static final byte DATA_CLASSIFICATION_NOT_ENABLED = 0x00;
-    static final byte MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION = 0x01;
+    static final byte MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION = 0x02;
 
     static final int AES_256_CBC = 1;
     static final int AEAD_AES_256_CBC_HMAC_SHA256 = 2;
@@ -6434,6 +6434,8 @@ final SQLServerConnection getConnection() {
     private boolean useColumnEncryption = false;
     private boolean serverSupportsColumnEncryption = false;
     private boolean serverSupportsDataClassification = false;
+    private byte serverSupportedDataClassificationVersion = TDS.DATA_CLASSIFICATION_NOT_ENABLED;
+
     private ColumnEncryptionVersion columnEncryptionVersion;
 
     private final byte valueBytes[] = new byte[256];
@@ -6461,6 +6463,7 @@ private static int nextReaderID() {
         serverSupportsColumnEncryption = con.getServerSupportsColumnEncryption();
         columnEncryptionVersion = con.getServerColumnEncryptionVersion();
         serverSupportsDataClassification = con.getServerSupportsDataClassification();
+        serverSupportedDataClassificationVersion = con.getServerSupportedDataClassificationVersion();
     }
 
     final boolean isColumnEncryptionSettingEnabled() {
@@ -6475,6 +6478,10 @@ final boolean getServerSupportsDataClassification() {
         return serverSupportsDataClassification;
     }
 
+    final byte getServerSupportedDataClassificationVersion() {
+        return serverSupportedDataClassificationVersion;
+    }
+
     final void throwInvalidTDS() throws SQLServerException {
         if (logger.isLoggable(Level.SEVERE))
             logger.severe(toString() + " got unexpected value in TDS response at offset:" + payloadOffset);
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java
index ec76e281b..a7d5d3da2 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java
@@ -680,11 +680,16 @@ ColumnEncryptionVersion getServerColumnEncryptionVersion() {
     }
 
     private boolean serverSupportsDataClassification = false;
+    private byte serverSupportedDataClassificationVersion = TDS.DATA_CLASSIFICATION_NOT_ENABLED;
 
     boolean getServerSupportsDataClassification() {
         return serverSupportsDataClassification;
     }
 
+    byte getServerSupportedDataClassificationVersion() {
+        return serverSupportedDataClassificationVersion;
+    }
+	
     // Boolean that indicates whether LOB objects created by this connection should be loaded into memory
     private boolean delayLoadingLobs = SQLServerDriverBooleanProperty.DELAY_LOADING_LOBS.getDefaultValue();
 
@@ -4669,9 +4674,9 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept
                     throw new SQLServerException(SQLServerException.getErrString("R_UnknownDataClsTokenNumber"), null);
                 }
 
-                byte supportedDataClassificationVersion = data[0];
-                if ((0 == supportedDataClassificationVersion)
-                        || (supportedDataClassificationVersion > TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION)) {
+                serverSupportedDataClassificationVersion = data[0];
+                if ((0 == serverSupportedDataClassificationVersion)
+                        || (serverSupportedDataClassificationVersion > TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION)) {
                     throw new SQLServerException(SQLServerException.getErrString("R_InvalidDataClsVersionNumber"),
                             null);
                 }
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java
index d9f41510a..c780b2c36 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java
@@ -455,6 +455,36 @@ public String toString() {
 }
 
 
+enum SensitivityRank {
+    NOT_DEFINED(-1),
+    NONE(0),
+    LOW(10),
+    MEDIUM(20),
+    HIGH(30),
+    CRITICAL(40);
+
+    private static final SensitivityRank[] VALUES = values();
+    private int rank;
+
+    private SensitivityRank(int rank) {
+        this.rank = rank;
+    }
+
+    public int getValue() {
+        return rank;
+    }
+
+    static boolean isValid(int rank) throws SQLServerException {
+        for (SensitivityRank r : VALUES) {
+            if (r.getValue() == rank) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+
 /**
  * Provides methods to connect to a SQL Server database and to obtain information about the JDBC driver.
  */
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java b/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java
index df8b031fd..7d0aac977 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java
@@ -259,42 +259,50 @@ private SensitivityClassification processDataClassification(TDSReader tdsReader)
         SensitivityClassification sensitivityClassification = null;
 
         // get the label count
-        int numLabels = tdsReader.readUnsignedShort();
-        List<Label> labels = new ArrayList<Label>(numLabels);
+        int sensitivityLabelCount = tdsReader.readUnsignedShort();
+        List<Label> sensitivityLabels = new ArrayList<Label>(sensitivityLabelCount);
 
-        for (int i = 0; i < numLabels; i++) {
-            labels.add(readSensitivityLabel(tdsReader));
+        for (int i = 0; i < sensitivityLabelCount; i++) {
+            sensitivityLabels.add(readSensitivityLabel(tdsReader));
         }
 
         // get the information type count
-        int numInformationTypes = tdsReader.readUnsignedShort();
+        int informationTypeCount = tdsReader.readUnsignedShort();
 
-        List<InformationType> informationTypes = new ArrayList<InformationType>(numInformationTypes);
-        for (int i = 0; i < numInformationTypes; i++) {
+        List<InformationType> informationTypes = new ArrayList<InformationType>(informationTypeCount);
+        for (int i = 0; i < informationTypeCount; i++) {
             informationTypes.add(readSensitivityInformationType(tdsReader));
         }
 
+        int sensitivityRank = SensitivityRank.NOT_DEFINED.getValue();
+        if (TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION <= tdsReader.getServerSupportedDataClassificationVersion()) {
+            sensitivityRank = tdsReader.readInt();
+            if (!SensitivityRank.isValid(sensitivityRank)) {
+                tdsReader.throwInvalidTDS();
+            }
+        }
+
         // get the per column classification data (corresponds to order of output columns for query)
-        int numResultColumns = tdsReader.readUnsignedShort();
+        int numResultSetColumns = tdsReader.readUnsignedShort();
 
-        List<ColumnSensitivity> columnSensitivities = new ArrayList<ColumnSensitivity>(numResultColumns);
-        for (int columnNum = 0; columnNum < numResultColumns; columnNum++) {
+        List<ColumnSensitivity> columnSensitivities = new ArrayList<ColumnSensitivity>(numResultSetColumns);
+        for (int columnNum = 0; columnNum < numResultSetColumns; columnNum++) {
 
             // get sensitivity properties for all the different sources which were used in generating the column output
-            int numSources = tdsReader.readUnsignedShort();
-            List<SensitivityProperty> sensitivityProperties = new ArrayList<SensitivityProperty>(numSources);
-            for (int sourceNum = 0; sourceNum < numSources; sourceNum++) {
+            int numSensitivityProperties = tdsReader.readUnsignedShort();
+            List<SensitivityProperty> sensitivityProperties = new ArrayList<SensitivityProperty>(
+                    numSensitivityProperties);
+            for (int sourceNum = 0; sourceNum < numSensitivityProperties; sourceNum++) {
 
                 // get the label index and then lookup label to use for source
-                int labelIndex = tdsReader.readUnsignedShort();
+                int sensitivityLabelIndex = tdsReader.readUnsignedShort();
                 Label label = null;
-                if (labelIndex != Integer.MAX_VALUE) {
-                    if (labelIndex >= labels.size()) {
+                if (sensitivityLabelIndex != Integer.MAX_VALUE) {
+                    if (sensitivityLabelIndex >= sensitivityLabels.size()) {
                         tdsReader.throwInvalidTDS();
                     }
-                    label = labels.get(labelIndex);
+                    label = sensitivityLabels.get(sensitivityLabelIndex);
                 }
-
                 // get the information type index and then lookup information type to use for source
                 int informationTypeIndex = tdsReader.readUnsignedShort();
                 InformationType informationType = null;
@@ -302,12 +310,22 @@ private SensitivityClassification processDataClassification(TDSReader tdsReader)
                     if (informationTypeIndex >= informationTypes.size()) {}
                     informationType = informationTypes.get(informationTypeIndex);
                 }
+
+                if (TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION <= tdsReader
+                        .getServerSupportedDataClassificationVersion()) {
+                    sensitivityRank = tdsReader.readInt();
+                    if (!SensitivityRank.isValid(sensitivityRank)) {
+                        tdsReader.throwInvalidTDS();
+                    }
+                }
+
                 // add sensitivity properties for the source
-                sensitivityProperties.add(new SensitivityProperty(label, informationType));
+                sensitivityProperties.add(new SensitivityProperty(label, informationType, sensitivityRank));
             }
             columnSensitivities.add(new ColumnSensitivity(sensitivityProperties));
         }
-        sensitivityClassification = new SensitivityClassification(labels, informationTypes, columnSensitivities);
+        sensitivityClassification = new SensitivityClassification(sensitivityLabels, informationTypes,
+                columnSensitivities);
         return sensitivityClassification;
     }
 
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java
index d4024a9fc..bccf5929c 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java
@@ -11,6 +11,7 @@
 public class SensitivityProperty {
     private Label label;
     private InformationType informationType;
+    private int sensitivityRank;
 
     /**
      * Constructs a SensitivityProperty
@@ -25,6 +26,22 @@ public SensitivityProperty(Label label, InformationType informationType) {
         this.informationType = informationType;
     }
 
+    /**
+     * Constructs a SensitivityProperty
+     * 
+     * @param label
+     *        Label as received from SQL Server for this SensitivityProperty
+     * @param informationType
+     *        InformationType as received from SQL Server for this SensitivityProperty
+     * @param sensitivityRank
+     *        sensitivity rank as received from SQL Server for this SensitivityProperty
+     */
+    public SensitivityProperty(Label label, InformationType informationType, int sensitivityRank) {
+        this.label = label;
+        this.informationType = informationType;
+        this.sensitivityRank = sensitivityRank;
+    }
+
     /**
      * Returns the label data for this <code>SensitivityProperty</code> Object
      * 
@@ -42,4 +59,8 @@ public Label getLabel() {
     public InformationType getInformationType() {
         return informationType;
     }
+
+    public int getSensitivityRank() {
+        return sensitivityRank;
+    }
 }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java
index 15c7311d6..e7667ccd8 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java
@@ -187,5 +187,6 @@ protected Object[][] getContents() {
             {"R_invalidEnclaveSessionFailed", "invalidate enclave session failed."},
             {"R_invalidEnclaveType", "Invalid enclave type {0}."},
             {"R_keystorePassword", "keystore password was incorrect"},
-            {"R_enclaveNotEnabled", "The statement triggers enclave computations"}};
+            {"R_enclaveNotEnabled", "The statement triggers enclave computations"},
+            {"R_dataClassificationNotSupported", "Data Classification is not supported on this server."}};
 }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java
index 19b1c97cc..a336a299f 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java
@@ -10,13 +10,19 @@
 import java.sql.Statement;
 import java.util.List;
 
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.platform.runner.JUnitPlatform;
 import org.junit.runner.RunWith;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import com.microsoft.sqlserver.jdbc.RandomUtil;
+import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
+import com.microsoft.sqlserver.jdbc.TestResource;
 import com.microsoft.sqlserver.jdbc.TestUtils;
 import com.microsoft.sqlserver.jdbc.dataclassification.InformationType;
 import com.microsoft.sqlserver.jdbc.dataclassification.Label;
@@ -27,25 +33,58 @@
 
 
 @RunWith(JUnitPlatform.class)
-@Tag(Constants.xAzureSQLDB)
-@Tag(Constants.xAzureSQLDW)
-@Tag(Constants.xSQLv12)
-@Tag(Constants.xSQLv14)
 public class DataClassificationTest extends AbstractTest {
-    private static final String tableName = RandomUtil.getIdentifier("DataClassification");
+    private static final String tableName = AbstractSQLGenerator
+            .escapeIdentifier(RandomUtil.getIdentifier("DataClassification"));
+
+    private static final String addSensitivitySql = "ADD SENSITIVITY CLASSIFICATION TO %s.%s WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='%s', INFORMATION_TYPE_ID='%s'%s)";
+    private static final String sensitivityRankSql = ", RANK=%s";
+    private static String sensitivityRank[][] = {{"NONE", "0"}, {"LOW", "10"}, {"MEDIUM", "20"}, {"HIGH", "30"},
+            {"CRITICAL", "40"}};
 
     /**
      * Tests data classification metadata information from SQL Server
      * 
      * @throws Exception
      */
+    @Tag(Constants.xSQLv12)
+    @Tag(Constants.xSQLv14)
     @Test
     public void testDataClassificationMetadata() throws Exception {
         try (Statement stmt = connection.createStatement();) {
-            assert (TestUtils.serverSupportsDataClassification(stmt));
-            createTable(connection, stmt);
-            runTestsForServer(stmt);
-            TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
+            if (!TestUtils.serverSupportsDataClassification(stmt)) {
+                fail(TestResource.getResource("R_dataClassificationNotSupported"));
+            }
+
+            for (int i = 0; i < sensitivityRank.length; i++) {
+                createTable(connection, stmt);
+                addSensitivity(connection, stmt, sensitivityRank[i][0]);
+                insertData(connection, stmt);
+                try (SQLServerResultSet rs = (SQLServerResultSet) stmt.executeQuery("SELECT * FROM " + tableName)) {
+                    verifySensitivityClassification(rs, Integer.parseInt(sensitivityRank[i][1]));
+                }
+                dropTable();
+            }
+        }
+    }
+
+    /**
+     * Tests data classification not supported
+     * 
+     * @throws SQLException
+     * @throws SQLServerException
+     * 
+     * @throws Exception
+     */
+    @Tag(Constants.xAzureSQLDB)
+    @Tag(Constants.xAzureSQLDW)
+    @Tag(Constants.xSQLv15)
+    @Test
+    public void testDataClassificationNotSupported() throws Exception {
+        try (Statement stmt = connection.createStatement();) {
+            if (TestUtils.serverSupportsDataClassification(stmt)) {
+                fail(TestResource.getResource("R_expectedFailPassed"));
+            }
         }
     }
 
@@ -57,26 +96,27 @@ public void testDataClassificationMetadata() throws Exception {
      * @throws SQLException
      */
     private void createTable(Connection connection, Statement stmt) throws SQLException {
-        String createQuery = "CREATE TABLE " + AbstractSQLGenerator.escapeIdentifier(tableName) + " ("
-                + "[Id] [int] IDENTITY(1,1) NOT NULL," + "[CompanyName] [nvarchar](40) NOT NULL,"
-                + "[ContactName] [nvarchar](50) NULL," + "[ContactTitle] [nvarchar](40) NULL,"
-                + "[City] [nvarchar](40) NULL," + "[CountryName] [nvarchar](40) NULL,"
+        String createQuery = "CREATE TABLE " + tableName + " (" + "[Id] [int] IDENTITY(1,1) NOT NULL,"
+                + "[CompanyName] [nvarchar](40) NOT NULL," + "[ContactName] [nvarchar](50) NULL,"
+                + "[ContactTitle] [nvarchar](40) NULL," + "[City] [nvarchar](40) NULL,"
+                + "[CountryName] [nvarchar](40) NULL,"
                 + "[Phone] [nvarchar](30) MASKED WITH (FUNCTION = 'default()') NULL,"
                 + "[Fax] [nvarchar](30) MASKED WITH (FUNCTION = 'default()') NULL)";
         stmt.execute(createQuery);
+    }
 
-        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + AbstractSQLGenerator.escapeIdentifier(tableName)
-                + ".CompanyName WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Company name', INFORMATION_TYPE_ID='COMPANY')");
-        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + AbstractSQLGenerator.escapeIdentifier(tableName)
-                + ".ContactName WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Person name', INFORMATION_TYPE_ID='NAME')");
-        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + AbstractSQLGenerator.escapeIdentifier(tableName)
-                + ".Phone WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Contact Information', INFORMATION_TYPE_ID='CONTACT')");
-        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + AbstractSQLGenerator.escapeIdentifier(tableName)
-                + ".Fax WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Contact Information', INFORMATION_TYPE_ID='CONTACT')");
+    private void addSensitivity(Connection connection, Statement stmt, String rank) throws SQLException {
+        String addRankSql = String.format(sensitivityRankSql, rank);
+        stmt.execute(String.format(addSensitivitySql, tableName, "CompanyName", "Company name", "COMPANY", addRankSql));
+        stmt.execute(String.format(addSensitivitySql, tableName, "ContactName", "Person name", "NAME", addRankSql));
+        stmt.execute(
+                String.format(addSensitivitySql, tableName, "Phone", "Contact Information", "CONTACT", addRankSql));
+        stmt.execute(String.format(addSensitivitySql, tableName, "Fax", "Contact Information", "CONTACT", addRankSql));
+    }
 
-        // INSERT ROWS OF DATA
-        try (PreparedStatement ps = connection.prepareStatement(
-                "INSERT INTO " + AbstractSQLGenerator.escapeIdentifier(tableName) + " VALUES (?,?,?,?,?,?,?)")) {
+    private void insertData(Connection connection, Statement stmt) throws SQLException {
+        try (PreparedStatement ps = connection
+                .prepareStatement("INSERT INTO " + tableName + " VALUES (?,?,?,?,?,?,?)")) {
 
             ps.setString(1, "Exotic Liquids");
             ps.setString(2, "Charlotte Cooper");
@@ -107,26 +147,14 @@ private void createTable(Connection connection, Statement stmt) throws SQLExcept
         }
     }
 
-    /**
-     * Selects data from the table and triggers verifySensitivityClassification method
-     * 
-     * @param stmt
-     * @throws Exception
-     */
-    private void runTestsForServer(Statement stmt) throws Exception {
-        try (SQLServerResultSet rs = (SQLServerResultSet) stmt
-                .executeQuery("SELECT * FROM " + AbstractSQLGenerator.escapeIdentifier(tableName))) {
-            verifySensitivityClassification(rs);
-        }
-    }
-
     /**
      * Verifies ResultSet received to contain data classification information as set.
      * 
      * @param rs
+     * @param rank
      * @throws SQLException
      */
-    private void verifySensitivityClassification(SQLServerResultSet rs) throws SQLException {
+    private void verifySensitivityClassification(SQLServerResultSet rs, int rank) throws SQLException {
         if (null != rs.getSensitivityClassification()) {
             for (int columnPos = 0; columnPos < rs.getSensitivityClassification().getColumnSensitivities().size();
                     columnPos++) {
@@ -143,25 +171,31 @@ private void verifySensitivityClassification(SQLServerResultSet rs) throws SQLEx
                     assert (labels.size() == 1);
                     verifyLabel(labels.get(0));
 
-                    if (columnPos == 1 || columnPos == 2 || columnPos == 6 || columnPos == 7) {
-                        verifyLabel(sp.getLabel());
-                        verifyInfoType(sp.getInformationType(), columnPos);
-                    }
+                    verifyLabel(sp.getLabel());
+                    verifyInfoType(sp.getInformationType(), columnPos);
+                    assertEquals(sp.getSensitivityRank(), rank, TestResource.getResource("R_valuesAreDifferent"));
                 }
             }
         }
     }
 
     private void verifyInfoType(InformationType informationType, int i) {
-        assert (informationType != null);
-        assert (informationType.getId().equalsIgnoreCase(i == 1 ? "COMPANY" : (i == 2 ? "NAME" : "CONTACT")));
-        assert (informationType.getName()
+        assertTrue(informationType != null);
+        assertTrue(informationType.getId().equalsIgnoreCase(i == 1 ? "COMPANY" : (i == 2 ? "NAME" : "CONTACT")));
+        assertTrue(informationType.getName()
                 .equalsIgnoreCase(i == 1 ? "Company name" : (i == 2 ? "Person Name" : "Contact Information")));
     }
 
     private void verifyLabel(Label label) {
-        assert (label != null);
-        assert (label.getId().equalsIgnoreCase("L1"));
-        assert (label.getName().equalsIgnoreCase("PII"));
+        assertTrue(label != null);
+        assertTrue(label.getId().equalsIgnoreCase("L1"));
+        assertTrue(label.getName().equalsIgnoreCase("PII"));
+    }
+
+    @AfterAll
+    public static void dropTable() throws Exception {
+        try (Statement stmt = connection.createStatement();) {
+            TestUtils.dropTableIfExists(tableName, stmt);
+        }
     }
 }