tableCompressions -> tableColumnCompressions

compression_verifier.go

@@ -48,29 +48,29 @@ type CompressionVerifier struct {
 
 // NewCompressionVerifier first checks the map for supported compression algorithms before
 // initializing and returning the initialized instance.
-func NewCompressionVerifier(tableCompressions map[string]map[string]string) (*CompressionVerifier, error) {
+func NewCompressionVerifier(tableColumnCompressions map[string]map[string]string) (*CompressionVerifier, error) {
 	supportedAlgorithms := make(map[string]struct{})
 	supportedAlgorithms[CompressionSnappy] = struct{}{}
 
 	compressionVerifier := &CompressionVerifier{
-		logger:              logrus.WithField("tag", "compression_verifier"),
-		supportedAlgorithms: supportedAlgorithms,
-		tableCompressions:   tableCompressions,
+		logger:                  logrus.WithField("tag", "compression_verifier"),
+		supportedAlgorithms:     supportedAlgorithms,
+		tableColumnCompressions: tableColumnCompressions,
 	}
 
-	if err := compressionVerifier.verifyConfiguredCompression(tableCompressions); err != nil {
+	if err := compressionVerifier.verifyConfiguredCompression(tableColumnCompressions); err != nil {
 		return nil, err
 	}
 
 	return compressionVerifier, nil
 }
 
-func (c *CompressionVerifier) verifyConfiguredCompression(tableCompressions map[string]map[string]string) error {
-	for table, columns := range tableCompressions {
+func (c *CompressionVerifier) verifyConfiguredCompression(tableColumnCompressions map[string]map[string]string) error {
+	for table, columns := range tableColumnCompressions {
 		for column, algorithm := range columns {
 			// Ensure algorithm is uppercased
 			algorithm = strings.ToUpper(algorithm)
-			tableCompressions[table][column] = algorithm
+			tableColumnCompressions[table][column] = algorithm
 
 			if _, ok := c.supportedAlgorithms[algorithm]; !ok {
 				return &UnsupportedCompressionError{

iterative_verifier.go

@@ -602,7 +602,7 @@ func compareHashes(source, target map[uint64][]byte) []uint64 {
 }
 
 func (v *IterativeVerifier) GetHashes(db *sql.DB, schema, table, pkColumn string, columns []schema.TableColumn, pks []uint64) (map[uint64][]byte, error) {
-	if tableCompression, ok := v.CompressionVerifier.tableCompressions[table]; ok {
+	if tableCompression, ok := v.CompressionVerifier.tableColumnCompressions[table]; ok {
 		// Use the CompressionVerifier to verify data equality
 		return v.CompressionVerifier.GetHashes(db, schema, table, pkColumn, columns, pks, tableCompression)
 	}