Aggiornamento della configurazione dello schema di partizionamento - Amazon Timestream
Aggiornare una tabella con una chiave di partizione

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Aggiornamento della configurazione dello schema di partizionamento

È possibile aggiornare la configurazione della tabella per lo schema di partizionamento con un'azione SDK with access the. UpdateTable

Aggiorna una tabella con una chiave di partizione

È possibile utilizzare i seguenti frammenti di codice per aggiornare una tabella con una chiave di partizione.

Java 
    public void updateTableCompositePartitionKeyEnforcement() {
        System.out.println("Updating table");

        UpdateTableRequest updateTableRequest = new UpdateTableRequest();
        updateTableRequest.setDatabaseName(DATABASE_NAME);
        updateTableRequest.setTableName(TABLE_NAME);

        // Can update enforcement level for dimension type partition key with OPTIONAL or REQUIRED enforcement
        final List<PartitionKey> partitionKeyWithDimensionAndRequiredEnforcement = Collections.singletonList(new PartitionKey()
            .withName(COMPOSITE_PARTITION_KEY_DIM_NAME)
            .withType(PartitionKeyType.DIMENSION)
            .withEnforcementInRecord(PartitionKeyEnforcementLevel.REQUIRED));
        Schema schema = new Schema();
        schema.setCompositePartitionKey(partitionKeyWithDimensionAndRequiredEnforcement);
        updateTableRequest.withSchema(schema);

        writeClient.updateTable(updateTableRequest);
        System.out.println("Table updated");
Java v2 
    public void updateTableCompositePartitionKeyEnforcement() {
        System.out.println("Updating table");
        // Can update enforcement level for dimension type partition key with OPTIONAL or REQUIRED enforcement
        final List<PartitionKey> partitionKeyWithDimensionAndRequiredEnforcement = Collections.singletonList(PartitionKey
            .builder()
            .name(COMPOSITE_PARTITION_KEY_DIM_NAME)
            .type(PartitionKeyType.DIMENSION)
            .enforcementInRecord(PartitionKeyEnforcementLevel.REQUIRED)
            .build());
        final Schema schema = Schema.builder()
                .compositePartitionKey(partitionKeyWithDimensionAndRequiredEnforcement).build();
        final UpdateTableRequest updateTableRequest = UpdateTableRequest.builder()
                .databaseName(DATABASE_NAME).tableName(TABLE_NAME).schema(schema).build();

        writeClient.updateTable(updateTableRequest);
        System.out.println("Table updated");
Go v1
 // Update table partition key enforcement attribute
    updateTableInput := &timestreamwrite.UpdateTableInput{
         DatabaseName: aws.String(*databaseName),
         TableName:    aws.String(*tableName),
         // Can update enforcement level for dimension type partition key with OPTIONAL or REQUIRED enforcement
         Schema: &timestreamwrite.Schema{
             CompositePartitionKey: []*timestreamwrite.PartitionKey{
                 {
                         Name:                aws.String(CompositePartitionKeyDimName),
                         EnforcementInRecord: aws.String("REQUIRED"),
                         Type:                aws.String("DIMENSION"),
                 },
             }},
     }
     updateTableOutput, err := writeSvc.UpdateTable(updateTableInput)
         if err != nil {
             fmt.Println("Error:")
             fmt.Println(err)
         } else {
             fmt.Println("Update table is successful, below is the output:")
             fmt.Println(updateTableOutput)
         }
Go v2
 // Update table partition key enforcement attribute
         updateTableInput := &timestreamwrite.UpdateTableInput{
             DatabaseName: aws.String(*databaseName),
             TableName:    aws.String(*tableName),
             // Can update enforcement level for dimension type partition key with OPTIONAL or REQUIRED enforcement
             Schema: &types.Schema{
                 CompositePartitionKey: []types.PartitionKey{
                     {
                         Name:                aws.String(CompositePartitionKeyDimName),
                         EnforcementInRecord: types.PartitionKeyEnforcementLevelRequired,
                         Type:                types.PartitionKeyTypeDimension,
                     },
                 }},
         }
         updateTableOutput, err := timestreamBuilder.WriteSvc.UpdateTable(context.TODO(), updateTableInput)
         if err != nil {
             fmt.Println("Error:")
             fmt.Println(err)
         } else {
             fmt.Println("Update table is successful, below is the output:")
             fmt.Println(updateTableOutput)
         }
Python 
    def update_table(self):
        print('Updating table')
        try:
            # Can update enforcement level for dimension type partition key with OPTIONAL or REQUIRED enforcement
            partition_key_with_dimension_and_required_enforcement = [
                {
                    'Type': 'DIMENSION', 
                    'Name': COMPOSITE_PARTITION_KEY_DIM_NAME, 
                    'EnforcementInRecord': 'REQUIRED'
                }
            ]
            schema = {
                'CompositePartitionKey': partition_key_with_dimension_and_required_enforcement
            }
            self.client.update_table(DatabaseName=DATABASE_NAME, TableName=TABLE_NAME,
                                     Schema=schema)
            print('Table updated.')
        except Exception as err:
            print('Update table failed:', err)