feat(bigtable): support row key schema for table. (#13614) (#23337)

[upstream:7fad263372825e11767174bd524ae055a663d45c]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/13614.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+bigtable: add `row_key_schema` to `google_bigtable_table` resource 
+```

google/services/bigtable/resource_bigtable_table.go

@@ -172,6 +172,17 @@ func ResourceBigtableTable() *schema.Resource {
 				},
 				Description: `Defines an automated backup policy for a table, specified by Retention Period and Frequency. To _create_ a table with automated backup disabled, either omit the automated_backup_policy argument, or set both Retention Period and Frequency properties to "0". To disable automated backup on an _existing_ table that has automated backup enabled, set _both_ Retention Period and Frequency properties to "0". When updating an existing table, to modify the Retention Period or Frequency properties of the resource's automated backup policy, set the respective property to a non-zero value. If the automated_backup_policy argument is not provided in the configuration on update, the resource's automated backup policy will _not_ be modified.`,
 			},
+			"row_key_schema": {
+				Type:             schema.TypeString,
+				Optional:         true,
+				DiffSuppressFunc: typeDiffFunc,
+				Description: `Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
+					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
+				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\n
+					
+					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
+					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".`,
+			},
 		},
 		UseJSONNumber: true,
 	}
@@ -323,6 +334,15 @@ func resourceBigtableTableCreate(d *schema.ResourceData, meta interface{}) error
 	}
 	tblConf.ColumnFamilies = columnFamilies
 
+	// Set the row key schema if given
+	if rks, ok := d.GetOk("row_key_schema"); ok {
+		parsedSchema, err := getRowKeySchema(rks)
+		if err != nil {
+			return err
+		}
+		tblConf.RowKeySchema = parsedSchema
+	}
+
 	// This method may return before the table's creation is complete - we may need to wait until
 	// it exists in the future.
 	// Set a longer timeout as creating table and adding column families can be pretty slow.
@@ -425,6 +445,17 @@ func resourceBigtableTableRead(d *schema.ResourceData, meta interface{}) error {
 		}
 	}
 
+	if table.RowKeySchema != nil {
+		marshalledRowKey, err := bigtable.MarshalJSON(*table.RowKeySchema)
+		if err != nil {
+			return err
+		}
+		d.Set("row_key_schema", string(marshalledRowKey))
+	} else {
+		// String value is default to empty string, so need to set it to nil to specify that the row key schema is not set.
+		d.Set("row_key_schema", nil)
+	}
+
 	return nil
 }
 
@@ -595,6 +626,23 @@ func resourceBigtableTableUpdate(d *schema.ResourceData, meta interface{}) error
 		}
 	}
 
+	if d.HasChange("row_key_schema") {
+		changedRks := d.Get("row_key_schema").(string)
+		if len(changedRks) == 0 {
+			if err := c.UpdateTableRemoveRowKeySchema(ctxWithTimeout, name); err != nil {
+				return fmt.Errorf("error removing row key schema on table %v: %v", name, err)
+			}
+		} else {
+			rks, err := getRowKeySchema(changedRks)
+			if err != nil {
+				return fmt.Errorf("failed to parse row key schema string %v: %v", changedRks, err)
+			}
+			if err = c.UpdateTableWithRowKeySchema(ctxWithTimeout, name, *rks); err != nil {
+				return fmt.Errorf("failed to update row key schema for table %v: %v", name, err)
+			}
+		}
+	}
+
 	return resourceBigtableTableRead(d, meta)
 }
 
@@ -705,3 +753,15 @@ func getType(input interface{}) (bigtable.Type, error) {
 	}
 	return output, nil
 }
+
+func getRowKeySchema(input interface{}) (*bigtable.StructType, error) {
+	rks, err := getType(input)
+	if err != nil {
+		return nil, err
+	}
+	structRks, ok := rks.(bigtable.StructType)
+	if !ok {
+		return nil, fmt.Errorf("only struct type is accepted as row key schema")
+	}
+	return &structRks, nil
+}

google/services/bigtable/resource_bigtable_table_meta.yaml

@@ -13,4 +13,5 @@ fields:
   - field: 'instance_name'
   - field: 'name'
   - field: 'project'
+  - field: 'row_key_schema'
   - field: 'split_keys'

google/services/bigtable/resource_bigtable_table_test.go

@@ -163,6 +163,97 @@ func TestAccBigtableTable_familyType(t *testing.T) {
 	})
 }
 
+func TestAccBigtableTable_testTableWithRowKeySchema(t *testing.T) {
+	// bigtable instance does not use the shared HTTP client, this test creates an instance
+	acctest.SkipIfVcr(t)
+	t.Parallel()
+
+	instanceName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	tableName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	family := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckBigtableTableDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccBigtableTable_rowKeySchema(instanceName, tableName, family, `{
+					"structType": {
+						"fields": [{
+							"fieldName": "myfield",
+							"type": {
+								"stringType": { "encoding": { "utf8Bytes": { } } }
+							}
+						}],
+						"encoding": { "orderedCodeBytes": { } }
+					}
+				}`),
+				Check: resource.ComposeTestCheckFunc(
+					testAccBigtableRowKeySchemaExists(t, "google_bigtable_table.table", true),
+				),
+			},
+			{
+				ResourceName:      "google_bigtable_table.table",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				// In-place modification is not accepted
+				Config: testAccBigtableTable_rowKeySchema(instanceName, tableName, family, `{
+					"structType": {
+						"fields": [{
+							"fieldName": "newfieldname",
+							"type": {
+								"stringType": { "encoding": { "utf8Bytes": { } } }
+							}
+						}],
+						"encoding": { "orderedCodeBytes": { } }
+					}
+				}`),
+				ExpectError: regexp.MustCompile(".*Row key schema in-place modification is not allowed.*"),
+			},
+			{
+				// Removing the schema is ok
+				Config: testAccBigtableTable_family(instanceName, tableName, family),
+				Check: resource.ComposeTestCheckFunc(
+					testAccBigtableRowKeySchemaExists(t, "google_bigtable_table.table", false),
+				),
+			},
+			{
+				ResourceName:      "google_bigtable_table.table",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			// Set the schema to a new one is ok
+			{
+				Config: testAccBigtableTable_rowKeySchema(instanceName, tableName, family, `{
+					"structType": {
+						"fields": [
+						    {
+								"fieldName": "mystringfield",
+								"type": {
+									"stringType": { "encoding": { "utf8Bytes": { } } }
+								}
+							},
+							{
+								"fieldName": "myintfield",
+								"type": {
+									"int64Type": { "encoding": { "bigEndianBytes": { } } }
+								}
+							}
+						],
+						"encoding": { "delimitedBytes": { "delimiter": "Iw==" } }
+					}
+				}`),
+				Check: resource.ComposeTestCheckFunc(
+					testAccBigtableRowKeySchemaExists(t, "google_bigtable_table.table", true),
+				),
+			},
+		},
+	})
+}
+
 func TestAccBigtableTable_deletion_protection_protected(t *testing.T) {
 	// bigtable instance does not use the shared HTTP client, this test creates an instance
 	acctest.SkipIfVcr(t)
@@ -708,6 +799,35 @@ func testAccBigtableColumnFamilyExists(t *testing.T, table_name_space, family st
 	}
 }
 
+func testAccBigtableRowKeySchemaExists(t *testing.T, table_name_space string, expected_has_schema bool) resource.TestCheckFunc {
+	ctx := context.Background()
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[table_name_space]
+		if !ok {
+			return fmt.Errorf("Table not found during schema check: %v", table_name_space)
+		}
+
+		config := acctest.GoogleProviderConfig(t)
+		c, err := config.BigTableClientFactory(config.UserAgent).NewAdminClient(config.Project, rs.Primary.Attributes["instance_name"])
+		if err != nil {
+			return fmt.Errorf("Error starting admin client %s", err)
+		}
+		defer c.Close()
+
+		table, err := c.TableInfo(ctx, rs.Primary.Attributes["name"])
+		if err != nil {
+			return fmt.Errorf("Error retrieving table. Could not find %s in %s", rs.Primary.Attributes["name"], rs.Primary.Attributes["instance_name"])
+		}
+
+		actual_has_schema := (table.RowKeySchema != nil)
+		if actual_has_schema != expected_has_schema {
+			return fmt.Errorf("expecting table to have row key schema to be %v, got %v", expected_has_schema, actual_has_schema)
+		}
+
+		return nil
+	}
+}
+
 func testAccBigtableChangeStreamDisabled(t *testing.T) resource.TestCheckFunc {
 	var ctx = context.Background()
 	return func(s *terraform.State) error {
@@ -862,6 +982,35 @@ EOF
 `, instanceName, instanceName, tableName, family, familyType)
 }
 
+func testAccBigtableTable_rowKeySchema(instanceName, tableName, family, rowKeySchema string) string {
+	return fmt.Sprintf(`
+resource "google_bigtable_instance" "instance" {
+  name = "%s"
+
+  cluster {
+    cluster_id = "%s"
+    zone       = "us-central1-b"
+  }
+
+  instance_type = "DEVELOPMENT"
+  deletion_protection = false
+}
+
+resource "google_bigtable_table" "table" {
+  name          = "%s"
+  instance_name = google_bigtable_instance.instance.name
+
+  column_family {
+    family = "%s"
+  }
+
+  row_key_schema = <<EOF
+%s 
+EOF
+}
+`, instanceName, instanceName, tableName, family, rowKeySchema)
+}
+
 func testAccBigtableTable_deletion_protection(instanceName, tableName, deletionProtection, family string) string {
 	return fmt.Sprintf(`
 resource "google_bigtable_instance" "instance" {