fixup! chore: bump Go version to 1.24 and golangci-lint

Author: cyrilgdn

.golangci.yml

@@ -3,8 +3,8 @@ version: "2"
 run:
   timeout: 5m
 
-issues:
-  exclude-rules:
-    - linters:
-        - errcheck
-      text: "Error return value of `d.Set` is not checked"
+linters:
+  settings:
+    errcheck:
+      exclude-functions:
+        - (*github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema.ResourceData).Set

postgresql/data_source_helpers.go

@@ -18,9 +18,9 @@ const (
 )
 
 func applyPatternMatchingToQuery(patternMatchingTarget string, d *schema.ResourceData) []string {
-	likeAnyPatterns := d.Get("like_any_patterns").([]interface{})
-	likeAllPatterns := d.Get("like_all_patterns").([]interface{})
-	notLikeAllPatterns := d.Get("not_like_all_patterns").([]interface{})
+	likeAnyPatterns := d.Get("like_any_patterns").([]any)
+	likeAllPatterns := d.Get("like_all_patterns").([]any)
+	notLikeAllPatterns := d.Get("not_like_all_patterns").([]any)
 	regexPattern := d.Get("regex_pattern").(string)
 
 	filters := []string{}
@@ -46,7 +46,7 @@ func generatePatternMatchingString(patternMatchingTarget string, additionalQuery
 	return patternMatchingFilter
 }
 
-func applyTypeMatchingToQuery(objectKeyword string, objects []interface{}) string {
+func applyTypeMatchingToQuery(objectKeyword string, objects []any) string {
 	var typeFilter string
 	if len(objects) > 0 {
 		typeFilter = fmt.Sprintf("%s = %s", objectKeyword, generatePatternArrayString(objects, queryArrayKeywordAny))
@@ -55,7 +55,7 @@ func applyTypeMatchingToQuery(objectKeyword string, objects []interface{}) strin
 	return typeFilter
 }
 
-func generatePatternArrayString(patterns []interface{}, queryArrayKeyword string) string {
+func generatePatternArrayString(patterns []any, queryArrayKeyword string) string {
 	formattedPatterns := []string{}
 
 	for _, pattern := range patterns {

postgresql/data_source_postgresql_schemas.go

@@ -129,9 +129,9 @@ func dataSourcePostgreSQLSchemasRead(db *DBConnection, d *schema.ResourceData) e
 func generateDataSourceSchemasID(d *schema.ResourceData, databaseName string) string {
 	return strings.Join([]string{
 		databaseName, strconv.FormatBool(d.Get("include_system_schemas").(bool)),
-		generatePatternArrayString(d.Get("like_any_patterns").([]interface{}), queryArrayKeywordAny),
-		generatePatternArrayString(d.Get("like_all_patterns").([]interface{}), queryArrayKeywordAll),
-		generatePatternArrayString(d.Get("not_like_all_patterns").([]interface{}), queryArrayKeywordAll),
+		generatePatternArrayString(d.Get("like_any_patterns").([]any), queryArrayKeywordAny),
+		generatePatternArrayString(d.Get("like_all_patterns").([]any), queryArrayKeywordAll),
+		generatePatternArrayString(d.Get("not_like_all_patterns").([]any), queryArrayKeywordAll),
 		d.Get("regex_pattern").(string),
 	}, "_")
 }

postgresql/data_source_postgresql_sequences.go

@@ -109,7 +109,7 @@ func dataSourcePostgreSQLSequencesRead(db *DBConnection, d *schema.ResourceData)
 		}
 	}()
 
-	sequences := make([]interface{}, 0)
+	sequences := make([]any, 0)
 	for rows.Next() {
 		var object_name string
 		var schema_name string
@@ -119,7 +119,7 @@ func dataSourcePostgreSQLSequencesRead(db *DBConnection, d *schema.ResourceData)
 			return fmt.Errorf("could not scan sequence output for database: %w", err)
 		}
 
-		result := make(map[string]interface{})
+		result := make(map[string]any)
 		result["object_name"] = object_name
 		result["schema_name"] = schema_name
 		result["data_type"] = data_type
@@ -135,17 +135,17 @@ func dataSourcePostgreSQLSequencesRead(db *DBConnection, d *schema.ResourceData)
 func generateDataSourceSequencesID(d *schema.ResourceData, databaseName string) string {
 	return strings.Join([]string{
 		databaseName,
-		generatePatternArrayString(d.Get("schemas").([]interface{}), queryArrayKeywordAny),
-		generatePatternArrayString(d.Get("like_any_patterns").([]interface{}), queryArrayKeywordAny),
-		generatePatternArrayString(d.Get("like_all_patterns").([]interface{}), queryArrayKeywordAll),
-		generatePatternArrayString(d.Get("not_like_all_patterns").([]interface{}), queryArrayKeywordAll),
+		generatePatternArrayString(d.Get("schemas").([]any), queryArrayKeywordAny),
+		generatePatternArrayString(d.Get("like_any_patterns").([]any), queryArrayKeywordAny),
+		generatePatternArrayString(d.Get("like_all_patterns").([]any), queryArrayKeywordAll),
+		generatePatternArrayString(d.Get("not_like_all_patterns").([]any), queryArrayKeywordAll),
 		d.Get("regex_pattern").(string),
 	}, "_")
 }
 
 func applySequenceDataSourceQueryFilters(query string, queryConcatKeyword string, d *schema.ResourceData) string {
 	filters := []string{}
-	schemasTypeFilter := applyTypeMatchingToQuery(sequenceSchemaKeyword, d.Get("schemas").([]interface{}))
+	schemasTypeFilter := applyTypeMatchingToQuery(sequenceSchemaKeyword, d.Get("schemas").([]any))
 	if len(schemasTypeFilter) > 0 {
 		filters = append(filters, schemasTypeFilter)
 	}

postgresql/data_source_postgresql_tables.go

@@ -117,7 +117,7 @@ func dataSourcePostgreSQLTablesRead(db *DBConnection, d *schema.ResourceData) er
 		}
 	}()
 
-	tables := make([]interface{}, 0)
+	tables := make([]any, 0)
 	for rows.Next() {
 		var object_name string
 		var schema_name string
@@ -127,7 +127,7 @@ func dataSourcePostgreSQLTablesRead(db *DBConnection, d *schema.ResourceData) er
 			return fmt.Errorf("could not scan table output for database: %w", err)
 		}
 
-		result := make(map[string]interface{})
+		result := make(map[string]any)
 		result["object_name"] = object_name
 		result["schema_name"] = schema_name
 		result["table_type"] = table_type
@@ -143,22 +143,22 @@ func dataSourcePostgreSQLTablesRead(db *DBConnection, d *schema.ResourceData) er
 func generateDataSourceTablesID(d *schema.ResourceData, databaseName string) string {
 	return strings.Join([]string{
 		databaseName,
-		generatePatternArrayString(d.Get("schemas").([]interface{}), queryArrayKeywordAny),
-		generatePatternArrayString(d.Get("table_types").([]interface{}), queryArrayKeywordAny),
-		generatePatternArrayString(d.Get("like_any_patterns").([]interface{}), queryArrayKeywordAny),
-		generatePatternArrayString(d.Get("like_all_patterns").([]interface{}), queryArrayKeywordAll),
-		generatePatternArrayString(d.Get("not_like_all_patterns").([]interface{}), queryArrayKeywordAll),
+		generatePatternArrayString(d.Get("schemas").([]any), queryArrayKeywordAny),
+		generatePatternArrayString(d.Get("table_types").([]any), queryArrayKeywordAny),
+		generatePatternArrayString(d.Get("like_any_patterns").([]any), queryArrayKeywordAny),
+		generatePatternArrayString(d.Get("like_all_patterns").([]any), queryArrayKeywordAll),
+		generatePatternArrayString(d.Get("not_like_all_patterns").([]any), queryArrayKeywordAll),
 		d.Get("regex_pattern").(string),
 	}, "_")
 }
 
 func applyTableDataSourceQueryFilters(query string, queryConcatKeyword string, d *schema.ResourceData) string {
 	filters := []string{}
-	schemasTypeFilter := applyTypeMatchingToQuery(tableSchemaKeyword, d.Get("schemas").([]interface{}))
+	schemasTypeFilter := applyTypeMatchingToQuery(tableSchemaKeyword, d.Get("schemas").([]any))
 	if len(schemasTypeFilter) > 0 {
 		filters = append(filters, schemasTypeFilter)
 	}
-	tableTypeFilter := applyTypeMatchingToQuery(tableTypeKeyword, d.Get("table_types").([]interface{}))
+	tableTypeFilter := applyTypeMatchingToQuery(tableTypeKeyword, d.Get("table_types").([]any))
 	if len(tableTypeFilter) > 0 {
 		filters = append(filters, tableTypeFilter)
 	}

postgresql/helpers.go

@@ -11,8 +11,8 @@ import (
 	"github.com/lib/pq"
 )
 
-func PGResourceFunc(fn func(*DBConnection, *schema.ResourceData) error) func(*schema.ResourceData, interface{}) error {
-	return func(d *schema.ResourceData, meta interface{}) error {
+func PGResourceFunc(fn func(*DBConnection, *schema.ResourceData) error) func(*schema.ResourceData, any) error {
+	return func(d *schema.ResourceData, meta any) error {
 		client := meta.(*Client)
 
 		db, err := client.Connect()
@@ -24,8 +24,8 @@ func PGResourceFunc(fn func(*DBConnection, *schema.ResourceData) error) func(*sc
 	}
 }
 
-func PGResourceExistsFunc(fn func(*DBConnection, *schema.ResourceData) (bool, error)) func(*schema.ResourceData, interface{}) (bool, error) {
-	return func(d *schema.ResourceData, meta interface{}) (bool, error) {
+func PGResourceExistsFunc(fn func(*DBConnection, *schema.ResourceData) (bool, error)) func(*schema.ResourceData, any) (bool, error) {
+	return func(d *schema.ResourceData, meta any) (bool, error) {
 		client := meta.(*Client)
 
 		db, err := client.Connect()
@@ -39,18 +39,18 @@ func PGResourceExistsFunc(fn func(*DBConnection, *schema.ResourceData) (bool, er
 
 // QueryAble is a DB connection (sql.DB/Tx)
 type QueryAble interface {
-	Exec(query string, args ...interface{}) (sql.Result, error)
-	Query(query string, args ...interface{}) (*sql.Rows, error)
-	QueryRow(query string, args ...interface{}) *sql.Row
+	Exec(query string, args ...any) (sql.Result, error)
+	Query(query string, args ...any) (*sql.Rows, error)
+	QueryRow(query string, args ...any) *sql.Row
 }
 
 // pqQuoteLiteral returns a string literal safe for inclusion in a PostgreSQL
 // query as a parameter.  The resulting string still needs to be wrapped in
 // single quotes in SQL (i.e. fmt.Sprintf(`'%s'`, pqQuoteLiteral("str"))).  See
 // quote_literal_internal() in postgresql/backend/utils/adt/quote.c:77.
 func pqQuoteLiteral(in string) string {
-	in = strings.Replace(in, `\`, `\\`, -1)
-	in = strings.Replace(in, `'`, `''`, -1)
+	in = strings.ReplaceAll(in, `\`, `\\`)
+	in = strings.ReplaceAll(in, `'`, `''`)
 	return in
 }
 
@@ -295,7 +295,7 @@ func resourcePrivilegesEqual(granted *schema.Set, d *schema.ResourceData) bool {
 
 	// implicit check: e.g. for object_type schema -> ALL == ["CREATE", "USAGE"]
 	log.Printf("The wanted privilege is 'ALL'. therefore, we will check if the current privileges are ALL implicitly")
-	implicits := []interface{}{}
+	implicits := []any{}
 	for _, p := range allowedPrivileges[objectType] {
 		if p != "ALL" {
 			implicits = append(implicits, p)
@@ -306,15 +306,15 @@ func resourcePrivilegesEqual(granted *schema.Set, d *schema.ResourceData) bool {
 }
 
 func pgArrayToSet(arr pq.ByteaArray) *schema.Set {
-	s := make([]interface{}, len(arr))
+	s := make([]any, len(arr))
 	for i, v := range arr {
 		s[i] = string(v)
 	}
 	return schema.NewSet(schema.HashString, s)
 }
 
 func stringSliceToSet(slice []string) *schema.Set {
-	s := make([]interface{}, len(slice))
+	s := make([]any, len(slice))
 	for i, v := range slice {
 		s[i] = v
 	}
@@ -459,12 +459,12 @@ func getDatabase(d *schema.ResourceData, databaseName string) string {
 
 func getDatabaseOwner(db QueryAble, database string) (string, error) {
 	dbQueryString := "$1"
-	dbQueryValues := []interface{}{database}
+	dbQueryValues := []any{database}
 
 	// Empty means current DB
 	if database == "" {
 		dbQueryString = "current_database()"
-		dbQueryValues = []interface{}{}
+		dbQueryValues = []any{}
 
 	}
 	query := fmt.Sprintf(`
@@ -599,8 +599,8 @@ func pgLockDatabase(txn *sql.Tx, database string) error {
 	return nil
 }
 
-func arrayDifference(a, b []interface{}) (diff []interface{}) {
-	m := make(map[interface{}]bool)
+func arrayDifference(a, b []any) (diff []any) {
+	m := make(map[any]bool)
 
 	for _, item := range b {
 		m[item] = true
@@ -614,8 +614,8 @@ func arrayDifference(a, b []interface{}) (diff []interface{}) {
 	return
 }
 
-func isUniqueArr(arr []interface{}) (interface{}, bool) {
-	keys := make(map[interface{}]bool, len(arr))
+func isUniqueArr(arr []any) (any, bool) {
+	keys := make(map[any]bool, len(arr))
 	for _, entry := range arr {
 		if _, value := keys[entry]; value {
 			return entry, false

postgresql/helpers_test.go

@@ -103,7 +103,7 @@ func TestArePrivilegesEqual(t *testing.T) {
 	}
 }
 
-func buildPrivilegesSet(grants ...interface{}) *schema.Set {
+func buildPrivilegesSet(grants ...any) *schema.Set {
 	return schema.NewSet(schema.HashString, grants)
 }
 

postgresql/model_pg_function.go

@@ -70,10 +70,10 @@ func (pgFunction *PGFunction) FromResourceData(d *schema.ResourceData) error {
 	argOutput := "void"
 
 	if args, ok := d.GetOk(funcArgAttr); ok {
-		args := args.([]interface{})
+		args := args.([]any)
 
 		for _, arg := range args {
-			arg := arg.(map[string]interface{})
+			arg := arg.(map[string]any)
 
 			var pgArg PGFunctionArg
 

postgresql/model_pg_function_test.go

@@ -243,7 +243,7 @@ func mockFunctionResourceData(t *testing.T, obj PGFunction) *schema.ResourceData
 
 	state.ID = ""
 	// Build the attribute map from ForemanModel
-	attributes := make(map[string]interface{})
+	attributes := make(map[string]any)
 
 	attributes["name"] = obj.Name
 	attributes["returns"] = obj.Returns
@@ -254,10 +254,10 @@ func mockFunctionResourceData(t *testing.T, obj PGFunction) *schema.ResourceData
 	attributes["parallel"] = obj.Parallel
 	attributes["volatility"] = obj.Volatility
 
-	var args []interface{}
+	var args []any
 
 	for _, a := range obj.Args {
-		args = append(args, map[string]interface{}{
+		args = append(args, map[string]any{
 			"type":    a.Type,
 			"name":    a.Name,
 			"mode":    a.Mode,

postgresql/provider.go

@@ -229,7 +229,7 @@ func Provider() *schema.Provider {
 	}
 }
 
-func validateExpectedVersion(v interface{}, key string) (warnings []string, errors []error) {
+func validateExpectedVersion(v any, key string) (warnings []string, errors []error) {
 	if _, err := semver.ParseTolerant(v.(string)); err != nil {
 		errors = append(errors, fmt.Errorf("invalid version (%q): %w", v.(string), err))
 	}
@@ -330,7 +330,7 @@ func acquireAzureOauthToken(tenantId string) (string, error) {
 	return token.Token, nil
 }
 
-func providerConfigure(d *schema.ResourceData) (interface{}, error) {
+func providerConfigure(d *schema.ResourceData) (any, error) {
 	var sslMode string
 	if sslModeRaw, ok := d.GetOk("sslmode"); ok {
 		sslMode = sslModeRaw.(string)
@@ -389,7 +389,7 @@ func providerConfigure(d *schema.ResourceData) (interface{}, error) {
 	}
 
 	if value, ok := d.GetOk("clientcert"); ok {
-		if spec, ok := value.([]interface{})[0].(map[string]interface{}); ok {
+		if spec, ok := value.([]any)[0].(map[string]interface{}); ok {
 			config.SSLClientCert = &ClientCertificateConfig{
 				CertificatePath: spec["cert"].(string),
 				KeyPath:         spec["key"].(string),