diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java
index d1aa53d7a..94e62341a 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java
@@ -73,6 +73,9 @@
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.TrustManagerFactory;
 import javax.net.ssl.X509TrustManager;
+
+import com.microsoft.sqlserver.jdbc.dataclassification.SensitivityClassification;
+
 import java.nio.Buffer;
 
 final class TDS {
@@ -100,9 +103,11 @@ final class TDS {
     static final int TDS_DONEPROC = 0xFE;
     static final int TDS_DONEINPROC = 0xFF;
     static final int TDS_FEDAUTHINFO = 0xEE;
+    static final int TDS_SQLRESCOLSRCS = 0xa2;
+    static final int TDS_SQLDATACLASSIFICATION = 0xa3;
 
     // FedAuth
-    static final int TDS_FEATURE_EXT_FEDAUTH = 0x02;
+    static final byte TDS_FEATURE_EXT_FEDAUTH = 0x02;
     static final int TDS_FEDAUTH_LIBRARY_SECURITYTOKEN = 0x01;
     static final int TDS_FEDAUTH_LIBRARY_ADAL = 0x02;
     static final int TDS_FEDAUTH_LIBRARY_RESERVED = 0x7F;
@@ -112,9 +117,17 @@ final class TDS {
     static final byte FEDAUTH_INFO_ID_SPN = 0x02; // FedAuthInfoData is the SPN to use for acquiring fed auth token
 
     // AE constants
-    static final int TDS_FEATURE_EXT_AE = 0x04;
-    static final int MAX_SUPPORTED_TCE_VERSION = 0x01; // max version
+    // 0x03 is for x_eFeatureExtensionId_Rcs
+    static final byte TDS_FEATURE_EXT_AE = 0x04;
+    static final byte MAX_SUPPORTED_TCE_VERSION = 0x01; // max version
     static final int CUSTOM_CIPHER_ALGORITHM_ID = 0; // max version
+    // 0x06 is for x_eFeatureExtensionId_LoginToken 
+    // 0x07 is for x_eFeatureExtensionId_ClientSideTelemetry 
+    // 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 int AES_256_CBC = 1;
     static final int AEAD_AES_256_CBC_HMAC_SHA256 = 2;
     static final int AE_METADATA = 0x08;
@@ -179,6 +192,8 @@ static final String getTokenName(int tdsTokenType) {
                 return "TDS_DONEINPROC (0xFF)";
             case TDS_FEDAUTHINFO:
                 return "TDS_FEDAUTHINFO (0xEE)";
+            case TDS_FEATURE_EXT_DATACLASSIFICATION:
+                return "TDS_FEATURE_EXT_DATACLASSIFICATION (0x09)";
             case TDS_FEATURE_EXT_UTF8SUPPORT:
                 return "TDS_FEATURE_EXT_UTF8SUPPORT (0x0A)";
             default:
@@ -6335,7 +6350,7 @@ final TDSCommand getCommand() {
     final SQLServerConnection getConnection() {
         return con;
     }
-
+    
     private TDSPacket currentPacket = new TDSPacket(0);
     private TDSPacket lastPacket = currentPacket;
     private int payloadOffset = 0;
@@ -6344,8 +6359,12 @@ final SQLServerConnection getConnection() {
     private boolean isStreaming = true;
     private boolean useColumnEncryption = false;
     private boolean serverSupportsColumnEncryption = false;
+    private boolean serverSupportsDataClassification = false;
 
     private final byte valueBytes[] = new byte[256];
+    
+    protected SensitivityClassification sensitivityClassification;
+
     private static final AtomicInteger lastReaderID = new AtomicInteger(0);
 
     private static int nextReaderID() {
@@ -6372,6 +6391,7 @@ private static int nextReaderID() {
             useColumnEncryption = true;
         }
         serverSupportsColumnEncryption = con.getServerSupportsColumnEncryption();
+        serverSupportsDataClassification = con.getServerSupportsDataClassification();
     }
 
     final boolean isColumnEncryptionSettingEnabled() {
@@ -6382,6 +6402,10 @@ final boolean getServerSupportsColumnEncryption() {
         return serverSupportsColumnEncryption;
     }
 
+    final boolean getServerSupportsDataClassification() {
+        return serverSupportsDataClassification;
+    }
+    
     final void throwInvalidTDS() throws SQLServerException {
         if (logger.isLoggable(Level.SEVERE))
             logger.severe(toString() + " got unexpected value in TDS response at offset:" + payloadOffset);
@@ -7073,7 +7097,7 @@ final void skip(int bytesToSkip) throws SQLServerException {
         }
     }
 
-    final void TryProcessFeatureExtAck(boolean featureExtAckReceived) throws SQLServerException {
+    final void tryProcessFeatureExtAck(boolean featureExtAckReceived) throws SQLServerException {
         // in case of redirection, do not check if TDS_FEATURE_EXTENSION_ACK is received or not.
         if (null != this.con.getRoutingInfo()) {
             return;
@@ -7082,6 +7106,10 @@ final void TryProcessFeatureExtAck(boolean featureExtAckReceived) throws SQLServ
         if (isColumnEncryptionSettingEnabled() && !featureExtAckReceived)
             throw new SQLServerException(this, SQLServerException.getErrString("R_AE_NotSupportedByServer"), null, 0, false);
     }
+
+    final void trySetSensitivityClassification(SensitivityClassification sensitivityClassification) {
+        this.sensitivityClassification = sensitivityClassification;
+    }
 }
 
 /**
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java
index 25debf539..be9fa8f50 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java
@@ -560,6 +560,12 @@ boolean getServerSupportsColumnEncryption() {
         return serverSupportsColumnEncryption;
     }
 
+    private boolean serverSupportsDataClassification = false;
+
+    boolean getServerSupportsDataClassification() {
+        return serverSupportsDataClassification;
+    }
+    
     static boolean isWindows;
     static Map<String, SQLServerColumnEncryptionKeyStoreProvider> globalSystemColumnEncryptionKeyStoreProviders = new HashMap<>();
     static {
@@ -3334,9 +3340,9 @@ int writeAEFeatureRequest(boolean write,
         int len = 6; // (1byte = featureID, 4bytes = featureData length, 1 bytes = Version)
 
         if (write) {
-            tdsWriter.writeByte((byte) TDS.TDS_FEATURE_EXT_AE); // FEATUREEXT_TCE
+            tdsWriter.writeByte(TDS.TDS_FEATURE_EXT_AE); // FEATUREEXT_TCE
             tdsWriter.writeInt(1);
-            tdsWriter.writeByte((byte) TDS.MAX_SUPPORTED_TCE_VERSION);
+            tdsWriter.writeByte(TDS.MAX_SUPPORTED_TCE_VERSION);
         }
         return len;
     }
@@ -3347,7 +3353,6 @@ int writeFedAuthFeatureRequest(boolean write,
                                                                                                                   * if false just calculates the
                                                                                                                   * length
                                                                                                                   */
-
         assert (fedAuthFeatureExtensionData.libraryType == TDS.TDS_FEDAUTH_LIBRARY_ADAL
                 || fedAuthFeatureExtensionData.libraryType == TDS.TDS_FEDAUTH_LIBRARY_SECURITYTOKEN);
 
@@ -3431,7 +3436,19 @@ int writeFedAuthFeatureRequest(boolean write,
         }
         return totalLen;
     }
-
+    
+    int writeDataClassificationFeatureRequest(boolean write /* if false just calculates the length */,
+            TDSWriter tdsWriter) throws SQLServerException {
+        int len = 6; // 1byte = featureID, 4bytes = featureData length, 1 bytes = Version
+        if (write) {
+            // Write Feature ID, length of the version# field and Sensitivity Classification Version#
+            tdsWriter.writeByte(TDS.TDS_FEATURE_EXT_DATACLASSIFICATION);
+            tdsWriter.writeInt(1);
+            tdsWriter.writeByte(TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION);
+        }
+        return len; // size of data written
+    }
+    
     int writeUTF8SupportFeatureRequest(boolean write,
             TDSWriter tdsWriter /* if false just calculates the length */) throws SQLServerException {
         int len = 5; // 1byte = featureID, 4bytes = featureData length
@@ -4066,7 +4083,7 @@ final void processFeatureExtAck(TDSReader tdsReader) throws SQLServerException {
         while (featureId != TDS.FEATURE_EXT_TERMINATOR);
     }
 
-    private void onFeatureExtAck(int featureId,
+    private void onFeatureExtAck(byte featureId,
             byte[] data) throws SQLServerException {
         if (null != routingInfo) {
             return;
@@ -4136,10 +4153,33 @@ private void onFeatureExtAck(int featureId,
                     throw new SQLServerException(SQLServerException.getErrString("R_InvalidAEVersionNumber"), null);
                 }
 
-                assert supportedTceVersion == TDS.MAX_SUPPORTED_TCE_VERSION; // Client support TCE version 1
                 serverSupportsColumnEncryption = true;
                 break;
             }
+            case TDS.TDS_FEATURE_EXT_DATACLASSIFICATION: {
+                if (connectionlogger.isLoggable(Level.FINER)) {
+                    connectionlogger.fine(toString() + " Received feature extension acknowledgement for Data Classification.");
+                }
+
+                if (2 != data.length) {
+                    if (connectionlogger.isLoggable(Level.SEVERE)) {
+                        connectionlogger.severe(toString() + " Unknown token for Data Classification.");
+                    }
+                    throw new SQLServerException(SQLServerException.getErrString("R_UnknownDataClsTokenNumber"), null);
+                }
+
+                byte supportedDataClassificationVersion = data[0];
+                if ((0 == supportedDataClassificationVersion)
+                        || (supportedDataClassificationVersion > TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION)) {
+                    if (connectionlogger.isLoggable(Level.SEVERE)) {
+                        connectionlogger.severe(toString() + " Invalid version number for Data Classification");
+                    }
+                    throw new SQLServerException(SQLServerException.getErrString("R_InvalidDataClsVersionNumber"), null);
+                }
+
+                byte enabled = data[1];
+                serverSupportsDataClassification = (enabled == 0) ? false : true;
+            }
             case TDS.TDS_FEATURE_EXT_UTF8SUPPORT: {
                 if (connectionlogger.isLoggable(Level.FINER)) {
                     connectionlogger.fine(toString() + " Received feature extension acknowledgement for UTF8 support.");
@@ -4439,9 +4479,12 @@ else if (serverMajorVersion >= 9) // Yukon (9.0) --> TDS 7.2 // Prelogin disconn
             len2 = len2 + writeFedAuthFeatureRequest(false, tdsWriter, fedAuthFeatureExtensionData);
         }
 
-        len2 = len2 + 1; // add 1 to length becaue of FeatureEx terminator
-
+        // Data Classification is always enabled (by default)
+        len2 += writeDataClassificationFeatureRequest(false, tdsWriter);
+        
         len2 = len2 + writeUTF8SupportFeatureRequest(false, tdsWriter);
+      
+        len2 = len2 + 1; // add 1 to length because of FeatureEx terminator
 
         // Length of entire Login 7 packet
         tdsWriter.writeInt(len2);
@@ -4622,6 +4665,7 @@ else if (serverMajorVersion >= 9) // Yukon (9.0) --> TDS 7.2 // Prelogin disconn
             writeFedAuthFeatureRequest(true, tdsWriter, fedAuthFeatureExtensionData);
         }
 
+        writeDataClassificationFeatureRequest(true, tdsWriter);
         writeUTF8SupportFeatureRequest(true, tdsWriter);
 
         tdsWriter.writeByte((byte) TDS.FEATURE_EXT_TERMINATOR);
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
index 80629cc64..52d80a4a2 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
@@ -72,6 +72,11 @@ public final class SQLServerException extends java.sql.SQLException {
     static final int DRIVER_ERROR_INTERMITTENT_TLS_FAILED = 7;
     static final int ERROR_SOCKET_TIMEOUT = 8;
     static final int ERROR_QUERY_TIMEOUT = 9;
+    static final int DATA_CLASSIFICATION_INVALID_VERSION = 10;
+    static final int DATA_CLASSIFICATION_NOT_EXPECTED = 11;
+    static final int DATA_CLASSIFICATION_INVALID_LABEL_INDEX = 12;
+    static final int DATA_CLASSIFICATION_INVALID_INFORMATION_TYPE_INDEX = 13;
+    
     private int driverErrorCode = DRIVER_ERROR_NONE;
 
     final int getDriverErrorCode() {
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java
index 483d00c4c..c2ba11f8e 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java
@@ -393,6 +393,8 @@ protected Object[][] getContents() {
 				{"R_invalidSSLProtocol", "SSL Protocol {0} label is not valid. Only TLS, TLSv1, TLSv1.1, and TLSv1.2 are supported."},
 				{"R_cancelQueryTimeoutPropertyDescription", "The number of seconds to wait to cancel sending a query timeout."},
 				{"R_invalidCancelQueryTimeout", "The cancel timeout value {0} is not valid."},
+				{"R_UnknownDataClsTokenNumber", "Unknown token for Data Classification."},	// From Server
+				{"R_InvalidDataClsVersionNumber", "Invalid version number {0} for Data Classification."},	// From Server
 				{"R_unknownUTF8SupportValue", "Unknown value for UTF8 support."},
 				{"R_illegalWKT", "Illegal Well-Known text. Please make sure Well-Known text is valid."},
 				{"R_illegalTypeForGeometry", "{0} is not supported for Geometry."},
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java
index e3a2296e3..31709297a 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java
@@ -31,6 +31,8 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Level;
 
+import com.microsoft.sqlserver.jdbc.dataclassification.SensitivityClassification;
+
 /**
  * Indicates the type of the row received from the server
  */
@@ -212,7 +214,17 @@ protected TDSReader getTDSReader() {
     }
 
     private final FetchBuffer fetchBuffer;
-
+    
+    /**
+     * Exposes Data Classification information for the current ResultSet For SQL Servers that do not support Data Classification or results that do
+     * not fetch any classified columns, this data can be null
+     * 
+     * @return SensitivityClassification
+     */
+    public SensitivityClassification getSensitivityClassification() {
+        return tdsReader.sensitivityClassification;
+    }
+    
     /**
      * Make a new result set
      * 
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java b/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java
index 3128fb318..e0f5342d9 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/StreamColumns.java
@@ -8,6 +8,16 @@
 
 package com.microsoft.sqlserver.jdbc;
 
+import java.util.List;
+
+import com.microsoft.sqlserver.jdbc.dataclassification.ColumnSensitivity;
+import com.microsoft.sqlserver.jdbc.dataclassification.InformationType;
+import com.microsoft.sqlserver.jdbc.dataclassification.Label;
+import com.microsoft.sqlserver.jdbc.dataclassification.SensitivityClassification;
+import com.microsoft.sqlserver.jdbc.dataclassification.SensitivityProperty;
+
+import java.util.ArrayList;
+
 /**
  * StreamColumns stores the column meta data for a result set. StreamColumns parses the inbound TDS packet stream to determine column meta data.
  */
@@ -210,6 +220,95 @@ void setFromTDS(TDSReader tdsReader) throws SQLServerException {
                 this.columns[numColumns] = new Column(typeInfo, columnName, tableName, null);
             }
         }
+
+        // Data Classification
+        if (tdsReader.getServerSupportsDataClassification() && tdsReader.peekTokenType() == TDS.TDS_SQLDATACLASSIFICATION) {
+            // Read and parse
+            tdsReader.trySetSensitivityClassification(processDataClassification(tdsReader));
+        }
+    }
+
+    private String readByteString(TDSReader tdsReader) throws SQLServerException {
+        String value = "";
+        int byteLen = (int) tdsReader.readUnsignedByte();
+        value = tdsReader.readUnicodeString(byteLen);
+        return value;
+    }
+
+    private Label readSensitivityLabel(TDSReader tdsReader) throws SQLServerException {
+        String name = readByteString(tdsReader);
+        String id = readByteString(tdsReader);
+        return new Label(name, id);
+    }
+
+    private InformationType readSensitivityInformationType(TDSReader tdsReader) throws SQLServerException {
+        String name = readByteString(tdsReader);
+        String id = readByteString(tdsReader);
+        return new InformationType(name, id);
+    }
+
+    private SensitivityClassification processDataClassification(TDSReader tdsReader) throws SQLServerException {
+        if (!tdsReader.getServerSupportsDataClassification()) {
+            tdsReader.throwInvalidTDS();
+        }
+
+        int dataClassificationToken = tdsReader.readUnsignedByte();
+        assert dataClassificationToken == TDS.TDS_SQLDATACLASSIFICATION;
+
+        SensitivityClassification sensitivityClassification = null;
+
+        // get the label count
+        int numLabels = tdsReader.readUnsignedShort();
+        List<Label> labels = new ArrayList<Label>(numLabels);
+
+        for (int i = 0; i < numLabels; i++) {
+            labels.add(readSensitivityLabel(tdsReader));
+        }
+
+        // get the information type count
+        int numInformationTypes = tdsReader.readUnsignedShort();
+
+        List<InformationType> informationTypes = new ArrayList<InformationType>(numInformationTypes);
+        for (int i = 0; i < numInformationTypes; i++) {
+            informationTypes.add(readSensitivityInformationType(tdsReader));
+        }
+
+        // get the per column classification data (corresponds to order of output columns for query)
+        int numResultColumns = tdsReader.readUnsignedShort();
+
+        List<ColumnSensitivity> columnSensitivities = new ArrayList<ColumnSensitivity>(numResultColumns);
+        for (int columnNum = 0; columnNum < numResultColumns; 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++) {
+
+                // get the label index and then lookup label to use for source
+                int labelIndex = tdsReader.readUnsignedShort();
+                Label label = null;
+                if (labelIndex != Integer.MAX_VALUE) {
+                    if (labelIndex >= labels.size()) {
+                        tdsReader.throwInvalidTDS();
+                    }
+                    label = labels.get(labelIndex);
+                }
+
+                // get the information type index and then lookup information type to use for source
+                int informationTypeIndex = tdsReader.readUnsignedShort();
+                InformationType informationType = null;
+                if (informationTypeIndex != Integer.MAX_VALUE) {
+                    if (informationTypeIndex >= informationTypes.size()) {
+                    }
+                    informationType = informationTypes.get(informationTypeIndex);
+                }
+                // add sensitivity properties for the source
+                sensitivityProperties.add(new SensitivityProperty(label, informationType));
+            }
+            columnSensitivities.add(new ColumnSensitivity(sensitivityProperties));
+        }
+        sensitivityClassification = new SensitivityClassification(labels, informationTypes, columnSensitivities);
+        return sensitivityClassification;
     }
 
     /**
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/ColumnSensitivity.java b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/ColumnSensitivity.java
new file mode 100644
index 000000000..9d56c13c0
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/ColumnSensitivity.java
@@ -0,0 +1,41 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc.dataclassification;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class is used to retrieve Sensitivity Information for columns as
+ * configured in Database.
+ */
+public class ColumnSensitivity {
+	private List<SensitivityProperty> sensitivityProperties;
+
+	/**
+	 * Constructor for ColumnSensitivity
+	 * 
+	 * @param sensitivityProperties
+	 *            List of sensitivity properties as received from SQL Server
+	 */
+	public ColumnSensitivity(List<SensitivityProperty> sensitivityProperties) {
+		this.sensitivityProperties = new ArrayList<SensitivityProperty>(
+				sensitivityProperties);
+	}
+
+	/**
+	 * Retrieves list of sensitivity properties as received from Server for this
+	 * <code>ColumnSensitivity</code> information
+	 * 
+	 * @return sensitivityProperties for this Class Object
+	 */
+	public List<SensitivityProperty> getSensitivityProperties() {
+		return sensitivityProperties;
+	}
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/InformationType.java b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/InformationType.java
new file mode 100644
index 000000000..d38aabac0
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/InformationType.java
@@ -0,0 +1,52 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc.dataclassification;
+
+import java.beans.ConstructorProperties;
+
+/**
+ * This class retrieves Information Types as recieved from SQL Server for the
+ * active resultSet
+ */
+public class InformationType {
+	private String name;
+	private String id;
+
+	/**
+	 * Constructor for Information Type
+	 * 
+	 * @param name
+	 *            Name of Information Type
+	 * @param id
+	 *            ID of Information Type
+	 */
+	@ConstructorProperties({"name", "id"})
+	public InformationType(String name, String id) {
+		this.name = name;
+		this.id = id;
+	}
+
+	/**
+	 * Retrieves Name of this <code>InformationType</code> Object
+	 * 
+	 * @return Name of Information Type
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Retrieves ID for this <code>InformationType</code> object
+	 * 
+	 * @return ID of Information Type
+	 */
+	public String getId() {
+		return id;
+	}
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/Label.java b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/Label.java
new file mode 100644
index 000000000..1ac08d0f8
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/Label.java
@@ -0,0 +1,52 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc.dataclassification;
+
+import java.beans.ConstructorProperties;
+
+/**
+ * This class retrieves Labels as recieved from SQL Server for the active
+ * resultSet
+ */
+public class Label {
+	private String name;
+	private String id;
+
+	/**
+	 * Constructor for Label
+	 * 
+	 * @param name
+	 *            Name of Label
+	 * @param id
+	 *            ID of Label
+	 */
+	@ConstructorProperties({"name", "id"})
+	public Label(String name, String id) {
+		this.name = name;
+		this.id = id;
+	}
+
+	/**
+	 * Retrieves Name of this <code>InformationType</code> Object
+	 * 
+	 * @return Name of Information Type
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Retrieves ID for this <code>InformationType</code> object
+	 * 
+	 * @return ID of Information Type
+	 */
+	public String getId() {
+		return id;
+	}
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityClassification.java b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityClassification.java
new file mode 100644
index 000000000..7c9b76e31
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityClassification.java
@@ -0,0 +1,75 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc.dataclassification;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class retrieves Sensitivity Classification data as recieved from SQL
+ * Server for the active resultSet
+ */
+public class SensitivityClassification {
+	private List<Label> labels;
+	private List<InformationType> informationTypes;
+	private List<ColumnSensitivity> columnSensitivities;
+
+	// Creating new ArrayList here assures that 'informationTypes' and 'labels'
+	// properties will not be null.
+	// The Count of the ColumnSensitivities property will be equal to the number
+	// of output columns for the query result set.
+	/**
+	 * Constructor for <code>SensitivityClassification</code> Object
+	 * 
+	 * @param labels
+	 *            Labels as received from SQL Server
+	 * @param informationTypes
+	 *            Information Types as received from SQL Server
+	 * @param columnSensitivity
+	 *            Column Sensitivities as received from SQL Server
+	 */
+	public SensitivityClassification(List<Label> labels,
+			List<InformationType> informationTypes,
+			List<ColumnSensitivity> columnSensitivity) {
+		this.labels = new ArrayList<Label>(labels);
+		this.informationTypes = new ArrayList<InformationType>(
+				informationTypes);
+		this.columnSensitivities = new ArrayList<ColumnSensitivity>(
+				columnSensitivity);
+	}
+
+	/**
+	 * Retrieves Labels for this <code>SensitivityClassification</code> Object
+	 * 
+	 * @return labels
+	 */
+	public List<Label> getLabels() {
+		return labels;
+	}
+
+	/**
+	 * Retrieves Information Types for this
+	 * <code>SensitivityClassification</code> Object
+	 * 
+	 * @return informationTypes
+	 */
+	public List<InformationType> getInformationTypes() {
+		return informationTypes;
+	}
+
+	/**
+	 * Retrieves Column Sensitivity for this
+	 * <code>SensitivityClassification</code> Object
+	 * 
+	 * @return columnSensitivities
+	 */
+	public List<ColumnSensitivity> getColumnSensitivities() {
+		return columnSensitivities;
+	}
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java
new file mode 100644
index 000000000..462c303e3
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dataclassification/SensitivityProperty.java
@@ -0,0 +1,51 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc.dataclassification;
+
+/**
+ * This class contains information about a Sensitivity Property as recieved from
+ * SQL Server for the active resultSet
+ */
+public class SensitivityProperty {
+	private Label label;
+	private InformationType informationType;
+
+	/**
+	 * Constructor for Sensitivity Property class object
+	 * 
+	 * @param label
+	 *            Label as recieved from SQL Server for this SensitivityProperty
+	 * @param informationType
+	 *            InformationType as recieved from SQL Server for this
+	 *            SensitivityProperty
+	 */
+	public SensitivityProperty(Label label, InformationType informationType) {
+		this.label = label;
+		this.informationType = informationType;
+	}
+
+	/**
+	 * Retrieves Label data for this <code>SensitivityProperty</code> Object
+	 * 
+	 * @return label
+	 */
+	public Label getLabel() {
+		return label;
+	}
+
+	/**
+	 * Retrieves InformationType data for this <code>SensitivityProperty</code>
+	 * Object
+	 * 
+	 * @return informationType
+	 */
+	public InformationType getInformationType() {
+		return informationType;
+	}
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java
index df34c8e6d..54a56e3ae 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java
@@ -102,7 +102,6 @@ static void parse(TDSReader tdsReader,
                 case TDS.TDS_FEDAUTHINFO:
                     parsing = tdsTokenHandler.onFedAuthInfo(tdsReader);
                     break;
-
                 case -1:
                     tdsReader.getCommand().onTokenEOF();
                     tdsTokenHandler.onEOF(tdsReader);
@@ -117,7 +116,7 @@ static void parse(TDSReader tdsReader,
 
         // if TDS_FEATURE_EXTENSION_ACK is not received verify if TDS_FEATURE_EXT_AE was sent
         if (isLoginAck && !isFeatureExtAck)
-            tdsReader.TryProcessFeatureExtAck(isFeatureExtAck);
+            tdsReader.tryProcessFeatureExtAck(isFeatureExtAck);
     }
 
     /* Handle unexpected tokens - throw an exception */
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java
new file mode 100644
index 000000000..759eb167d
--- /dev/null
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/resultset/DataClassificationTest.java
@@ -0,0 +1,139 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+package com.microsoft.sqlserver.jdbc.resultset;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
+import com.microsoft.sqlserver.jdbc.dataclassification.SensitivityProperty;
+import com.microsoft.sqlserver.testframework.AbstractTest;
+import com.microsoft.sqlserver.testframework.Utils;
+import com.microsoft.sqlserver.testframework.util.RandomUtil;
+import com.microsoft.sqlserver.testframework.util.Util;
+
+@RunWith(JUnitPlatform.class)
+public class DataClassificationTest extends AbstractTest {
+    private static final String tableName = "[" + RandomUtil.getIdentifier("DataClassification") + "]";
+
+    /**
+     * Tests data classification metadata information from SQL Server
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testDataClassificationMetadata() throws Exception {
+        // Run this test only with newer SQL Servers (version>=2018) that support Data Classification
+        try (Connection con = DriverManager.getConnection(connectionString); Statement stmt = connection.createStatement();) {
+            if (Util.serverSupportsDataClassification(stmt)) {
+                createTable(connection, stmt);
+                runTestsForServer(stmt);
+                Utils.dropTableIfExists(tableName, stmt);
+            }
+        }
+    }
+
+    /**
+     * Creates a new table in database with data classification column tags Inserts rows of data in the table
+     * 
+     * @param connection
+     * @param stmt
+     * @throws SQLException
+     */
+    private void createTable(Connection connection,
+            Statement stmt) throws SQLException {
+        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,"
+                + "[Country] [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 " + tableName
+                + ".CompanyName WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Company name', INFORMATION_TYPE_ID='COMPANY')");
+        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + tableName
+                + ".ContactName WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Person name', INFORMATION_TYPE_ID='NAME')");
+        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + tableName
+                + ".Phone WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Contact Information', INFORMATION_TYPE_ID='CONTACT')");
+        stmt.execute("ADD SENSITIVITY CLASSIFICATION TO " + tableName
+                + ".Fax WITH (LABEL='PII', LABEL_ID='L1', INFORMATION_TYPE='Contact Information', INFORMATION_TYPE_ID='CONTACT')");
+
+        // INSERT ROWS OF DATA
+        try (PreparedStatement ps = connection.prepareStatement("INSERT INTO " + tableName + " VALUES (?,?,?,?,?,?,?)")) {
+
+            ps.setString(1, "Exotic Liquids");
+            ps.setString(2, "Charlotte Cooper");
+            ps.setObject(3, null);
+            ps.setObject(4, "London");
+            ps.setString(5, "UK");
+            ps.setString(6, "(171) 555-2222");
+            ps.setString(7, null);
+            ps.execute();
+
+            ps.setString(1, "New Orleans");
+            ps.setString(2, "Cajun Delights");
+            ps.setObject(3, null);
+            ps.setObject(4, "New Orleans");
+            ps.setString(5, "USA");
+            ps.setString(6, "(100) 555-4822");
+            ps.setString(7, null);
+            ps.execute();
+
+            ps.setString(1, "Grandma Kelly's Homestead");
+            ps.setString(2, "Regina Murphy");
+            ps.setObject(3, null);
+            ps.setObject(4, "Ann Arbor");
+            ps.setString(5, "USA");
+            ps.setString(6, "(313) 555-5735");
+            ps.setString(7, "(313) 555-3349");
+            ps.execute();
+        }
+    }
+
+    /**
+     * 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 " + tableName)) {
+            verifySensitivityClassification(rs);
+        }
+    }
+
+    /**
+     * Verifies resultset received to contain data classification information as set.
+     * 
+     * @param rs
+     * @throws SQLException
+     */
+    private void verifySensitivityClassification(SQLServerResultSet rs) throws SQLException {
+        if (null != rs.getSensitivityClassification()) {
+            for (int columnPos = 0; columnPos < rs.getSensitivityClassification().getColumnSensitivities().size(); columnPos++) {
+                for (SensitivityProperty sp : rs.getSensitivityClassification().getColumnSensitivities().get(columnPos).getSensitivityProperties()) {
+                    if (columnPos == 1 || columnPos == 2 || columnPos == 6 || columnPos == 7) {
+                        assert (sp.getLabel() != null);
+                        assert (sp.getLabel().getId().equalsIgnoreCase("L1"));
+                        assert (sp.getLabel().getName().equalsIgnoreCase("PII"));
+
+                        assert (sp.getInformationType() != null);
+                        assert (sp.getInformationType().getId().equalsIgnoreCase(columnPos == 1 ? "COMPANY" : (columnPos == 2 ? "NAME" : "CONTACT")));
+                        assert (sp.getInformationType().getName()
+                                .equalsIgnoreCase(columnPos == 1 ? "Company name" : (columnPos == 2 ? "Person Name" : "Contact Information")));
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java b/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java
index 9df214e99..ee4ea2c75 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java
@@ -309,6 +309,25 @@ public static boolean supportJDBC43(Connection con) throws SQLException {
         return (meta.getJDBCMajorVersion() >= 4 && meta.getJDBCMinorVersion() >= 3);
     }
 
+    /**
+     * Checks if object SYS.SENSITIVITY_CLASSIFICATIONS exists in SQL Server
+     * 
+     * @param Statement
+     * @return boolean
+     */
+    public static boolean serverSupportsDataClassification(Statement stmt) {
+        try {
+            stmt.execute("SELECT * FROM SYS.SENSITIVITY_CLASSIFICATIONS");
+        }
+        catch (SQLException e) {
+            // Check for Error 208: Invalid Object Name
+            if (e.getErrorCode() == 208) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /**
      * 
      * @param b