github.com/ffrizzo/terraform@v0.8.2-0.20161219200057-992e12335f3d/builtin/providers/postgresql/resource_postgresql_schema.go (about)

     1  package postgresql
     2  
     3  import (
     4  	"bytes"
     5  	"database/sql"
     6  	"errors"
     7  	"fmt"
     8  	"log"
     9  
    10  	"github.com/hashicorp/errwrap"
    11  	"github.com/hashicorp/terraform/helper/schema"
    12  	"github.com/lib/pq"
    13  )
    14  
    15  const (
    16  	schemaNameAttr = "name"
    17  )
    18  
    19  func resourcePostgreSQLSchema() *schema.Resource {
    20  	return &schema.Resource{
    21  		Create: resourcePostgreSQLSchemaCreate,
    22  		Read:   resourcePostgreSQLSchemaRead,
    23  		Update: resourcePostgreSQLSchemaUpdate,
    24  		Delete: resourcePostgreSQLSchemaDelete,
    25  		Importer: &schema.ResourceImporter{
    26  			State: schema.ImportStatePassthrough,
    27  		},
    28  
    29  		Schema: map[string]*schema.Schema{
    30  			schemaNameAttr: {
    31  				Type:        schema.TypeString,
    32  				Required:    true,
    33  				Description: "The name of the schema",
    34  			},
    35  		},
    36  	}
    37  }
    38  
    39  func resourcePostgreSQLSchemaCreate(d *schema.ResourceData, meta interface{}) error {
    40  	c := meta.(*Client)
    41  	conn, err := c.Connect()
    42  	if err != nil {
    43  		return errwrap.Wrapf("Error connecting to PostgreSQL: {{err}}", err)
    44  	}
    45  	defer conn.Close()
    46  
    47  	schemaName := d.Get(schemaNameAttr).(string)
    48  	b := bytes.NewBufferString("CREATE SCHEMA ")
    49  	fmt.Fprintf(b, pq.QuoteIdentifier(schemaName))
    50  
    51  	query := b.String()
    52  	_, err = conn.Query(query)
    53  	if err != nil {
    54  		return errwrap.Wrapf(fmt.Sprintf("Error creating schema %s: {{err}}", schemaName), err)
    55  	}
    56  
    57  	d.SetId(schemaName)
    58  
    59  	return resourcePostgreSQLSchemaRead(d, meta)
    60  }
    61  
    62  func resourcePostgreSQLSchemaDelete(d *schema.ResourceData, meta interface{}) error {
    63  	client := meta.(*Client)
    64  	conn, err := client.Connect()
    65  	if err != nil {
    66  		return err
    67  	}
    68  	defer conn.Close()
    69  
    70  	schemaName := d.Get(schemaNameAttr).(string)
    71  	query := fmt.Sprintf("DROP SCHEMA %s", pq.QuoteIdentifier(schemaName))
    72  	_, err = conn.Query(query)
    73  	if err != nil {
    74  		return errwrap.Wrapf("Error deleting schema: {{err}}", err)
    75  	}
    76  
    77  	d.SetId("")
    78  
    79  	return nil
    80  }
    81  
    82  func resourcePostgreSQLSchemaRead(d *schema.ResourceData, meta interface{}) error {
    83  	c := meta.(*Client)
    84  	conn, err := c.Connect()
    85  	if err != nil {
    86  		return err
    87  	}
    88  	defer conn.Close()
    89  
    90  	schemaId := d.Id()
    91  	var schemaName string
    92  	err = conn.QueryRow("SELECT nspname FROM pg_catalog.pg_namespace WHERE nspname=$1", schemaId).Scan(&schemaName)
    93  	switch {
    94  	case err == sql.ErrNoRows:
    95  		log.Printf("[WARN] PostgreSQL schema (%s) not found", schemaId)
    96  		d.SetId("")
    97  		return nil
    98  	case err != nil:
    99  		return errwrap.Wrapf("Error reading schema: {{err}}", err)
   100  	default:
   101  		d.Set(schemaNameAttr, schemaName)
   102  		d.SetId(schemaName)
   103  		return nil
   104  	}
   105  }
   106  
   107  func resourcePostgreSQLSchemaUpdate(d *schema.ResourceData, meta interface{}) error {
   108  	c := meta.(*Client)
   109  	conn, err := c.Connect()
   110  	if err != nil {
   111  		return err
   112  	}
   113  	defer conn.Close()
   114  
   115  	if err := setSchemaName(conn, d); err != nil {
   116  		return err
   117  	}
   118  
   119  	return resourcePostgreSQLSchemaRead(d, meta)
   120  }
   121  
   122  func setSchemaName(conn *sql.DB, d *schema.ResourceData) error {
   123  	if !d.HasChange(schemaNameAttr) {
   124  		return nil
   125  	}
   126  
   127  	oraw, nraw := d.GetChange(schemaNameAttr)
   128  	o := oraw.(string)
   129  	n := nraw.(string)
   130  	if n == "" {
   131  		return errors.New("Error setting schema name to an empty string")
   132  	}
   133  
   134  	query := fmt.Sprintf("ALTER SCHEMA %s RENAME TO %s", pq.QuoteIdentifier(o), pq.QuoteIdentifier(n))
   135  	if _, err := conn.Query(query); err != nil {
   136  		return errwrap.Wrapf("Error updating schema NAME: {{err}}", err)
   137  	}
   138  	d.SetId(n)
   139  
   140  	return nil
   141  }