Data Sources for schema sequence and table (#214)

Co-authored-by: Cyril Gaudin <[email protected]>
Co-authored-by: Warnar Boekkooi <[email protected]>
Co-authored-by: Jean-Louis Giordano <[email protected]>
Co-authored-by: Alec Rabold <[email protected]>

Author: 5 people

postgresql/data_source_helpers.go

@@ -0,0 +1,73 @@
+package postgresql
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+const (
+	queryConcatKeywordWhere = "WHERE"
+	queryConcatKeywordAnd   = "AND"
+	queryArrayKeywordAny    = "ANY"
+	queryArrayKeywordAll    = "ALL"
+	likePatternQuery        = "LIKE"
+	notLikePatternQuery     = "NOT LIKE"
+	regexPatternQuery       = "~"
+)
+
+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{})
+	regexPattern := d.Get("regex_pattern").(string)
+
+	filters := []string{}
+	if len(likeAnyPatterns) > 0 {
+		filters = append(filters, generatePatternMatchingString(patternMatchingTarget, likePatternQuery, generatePatternArrayString(likeAnyPatterns, queryArrayKeywordAny)))
+	}
+	if len(likeAllPatterns) > 0 {
+		filters = append(filters, generatePatternMatchingString(patternMatchingTarget, likePatternQuery, generatePatternArrayString(likeAllPatterns, queryArrayKeywordAll)))
+	}
+	if len(notLikeAllPatterns) > 0 {
+		filters = append(filters, generatePatternMatchingString(patternMatchingTarget, notLikePatternQuery, generatePatternArrayString(notLikeAllPatterns, queryArrayKeywordAll)))
+	}
+	if regexPattern != "" {
+		filters = append(filters, generatePatternMatchingString(patternMatchingTarget, regexPatternQuery, fmt.Sprintf("'%s'", regexPattern)))
+	}
+
+	return filters
+}
+
+func generatePatternMatchingString(patternMatchingTarget string, additionalQueryKeyword string, pattern string) string {
+	patternMatchingFilter := fmt.Sprintf("%s %s %s", patternMatchingTarget, additionalQueryKeyword, pattern)
+
+	return patternMatchingFilter
+}
+
+func applyTypeMatchingToQuery(objectKeyword string, objects []interface{}) string {
+	var typeFilter string
+	if len(objects) > 0 {
+		typeFilter = fmt.Sprintf("%s = %s", objectKeyword, generatePatternArrayString(objects, queryArrayKeywordAny))
+	}
+
+	return typeFilter
+}
+
+func generatePatternArrayString(patterns []interface{}, queryArrayKeyword string) string {
+	formattedPatterns := []string{}
+
+	for _, pattern := range patterns {
+		formattedPatterns = append(formattedPatterns, fmt.Sprintf("'%s'", pattern.(string)))
+	}
+	return fmt.Sprintf("%s (array[%s])", queryArrayKeyword, strings.Join(formattedPatterns, ","))
+}
+
+func finalizeQueryWithFilters(query string, queryConcatKeyword string, filters []string) string {
+	if len(filters) > 0 {
+		query = fmt.Sprintf("%s %s %s", query, queryConcatKeyword, strings.Join(filters, " AND "))
+	}
+
+	return query
+}

postgresql/data_source_postgresql_schemas.go

@@ -0,0 +1,139 @@
+package postgresql
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+var schemaQueries = map[string]string{
+	"query_include_system_schemas": `
+	SELECT schema_name
+	FROM information_schema.schemata
+	`,
+	"query_exclude_system_schemas": `
+	SELECT schema_name
+	FROM information_schema.schemata
+	WHERE schema_name NOT LIKE 'pg_%'
+	AND schema_name <> 'information_schema'
+	`,
+}
+
+const schemaPatternMatchingTarget = "schema_name"
+
+func dataSourcePostgreSQLDatabaseSchemas() *schema.Resource {
+	return &schema.Resource{
+		Read: PGResourceFunc(dataSourcePostgreSQLSchemasRead),
+		Schema: map[string]*schema.Schema{
+			"database": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				Description: "The PostgreSQL database which will be queried for schema names",
+			},
+			"include_system_schemas": {
+				Type:        schema.TypeBool,
+				Default:     false,
+				Optional:    true,
+				Description: "Determines whether to include system schemas (pg_ prefix and information_schema). 'public' will always be included.",
+			},
+			"like_any_patterns": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Elem:        &schema.Schema{Type: schema.TypeString},
+				MinItems:    0,
+				Description: "Expression(s) which will be pattern matched in the query using the PostgreSQL LIKE ANY operator",
+			},
+			"like_all_patterns": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Elem:        &schema.Schema{Type: schema.TypeString},
+				MinItems:    0,
+				Description: "Expression(s) which will be pattern matched in the query using the PostgreSQL LIKE ALL operator",
+			},
+			"not_like_all_patterns": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Elem:        &schema.Schema{Type: schema.TypeString},
+				MinItems:    0,
+				Description: "Expression(s) which will be pattern matched in the query using the PostgreSQL NOT LIKE ALL operator",
+			},
+			"regex_pattern": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "Expression which will be pattern matched in the query using the PostgreSQL ~ (regular expression match) operator",
+			},
+			"schemas": {
+				Type:        schema.TypeSet,
+				Computed:    true,
+				Elem:        &schema.Schema{Type: schema.TypeString},
+				Set:         schema.HashString,
+				Description: "The list of PostgreSQL schemas retrieved by this data source",
+			},
+		},
+	}
+}
+
+func dataSourcePostgreSQLSchemasRead(db *DBConnection, d *schema.ResourceData) error {
+	database := d.Get("database").(string)
+
+	txn, err := startTransaction(db.client, database)
+	if err != nil {
+		return err
+	}
+	defer deferredRollback(txn)
+
+	includeSystemSchemas := d.Get("include_system_schemas").(bool)
+
+	var query string
+	var queryConcatKeyword string
+	if includeSystemSchemas {
+		query = schemaQueries["query_include_system_schemas"]
+		queryConcatKeyword = queryConcatKeywordWhere
+	} else {
+		query = schemaQueries["query_exclude_system_schemas"]
+		queryConcatKeyword = queryConcatKeywordAnd
+	}
+
+	query = applySchemaDataSourceQueryFilters(query, queryConcatKeyword, d)
+
+	rows, err := txn.Query(query)
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+
+	schemas := []string{}
+	for rows.Next() {
+		var schema string
+
+		if err = rows.Scan(&schema); err != nil {
+			return fmt.Errorf("could not scan schema name for database: %w", err)
+		}
+		schemas = append(schemas, schema)
+	}
+
+	d.Set("schemas", stringSliceToSet(schemas))
+	d.SetId(generateDataSourceSchemasID(d, database))
+
+	return nil
+}
+
+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),
+		d.Get("regex_pattern").(string),
+	}, "_")
+}
+
+func applySchemaDataSourceQueryFilters(query string, queryConcatKeyword string, d *schema.ResourceData) string {
+	filters := []string{}
+	filters = append(filters, applyPatternMatchingToQuery(schemaPatternMatchingTarget, d)...)
+
+	return finalizeQueryWithFilters(query, queryConcatKeyword, filters)
+}