> ## Documentation Index > Fetch the complete documentation index at: https://docs.maia.ai/llms.txt > Use this file to discover all available pages before exploring further. # Table Update export const ComponentMetadata = ({warehouses, unsupportedWarehouses = [], componentType, connectionInputs, connectionOutputs}) => { const allWarehouses = [...warehouses.map(w => ({ name: w, supported: true })), ...unsupportedWarehouses.map(w => ({ name: w, supported: false }))]; return

Project Availability	{allWarehouses.map((w, i) => {w.name} {w.supported ? '✅' : '❌'} )}
Component Type	{componentType}
Connection Inputs	{connectionInputs}
Connection Outputs	{connectionOutputs}

; }; The **Table Update** transformation component lets you update a set of existing records in a target table. The component attempts to match rows in your input dataset with rows in the target table, and updates selected columns in the target row wherever a match is found. The match is based on matching keys in the input dataset and the target tables. It's very important that the keys uniquely identify the rows, and that the keys aren't NULL. Successful validation of this component ensures the target table exists and the target columns have been found. However, data is only written to the table when the pipeline containing the table update is actually run. Most potential problems are avoided by a successful validation; however, run-time errors can still occur during execution. This component is equivalent to using the SQL **MERGE INTO** statement. The **Join Expression** property defines the matching condition, **When Matched** defines the action on matched rows, **Update Mapping** maps which columns to overwrite, and **Include Not Matched** optionally inserts unmatched rows. There are other components that can write data to a table and may better suit your use case: * To output data to a new table, use [Rewrite Table](/docs/components/rewrite-table). * To output data to an existing table, appending to or replacing the current contents, use [Table Output](/docs/components/table-output). ### Use case Table Update is typically used in pipelines when you're working with slowly changing dimensions, CDC (change data capture), or data harmonization. Some typical examples of use are: * Overwriting existing attributes in a table row when changes are detected. For example, when a customer updates their email address or phone number, you need to update that single field without overwriting the rest of the data. * Change data capture (CDC) handling. For example, ingesting change logs from an upstream system and reflecting those changes in your warehouse table. * Synchronizing reference or lookup tables. For example, updating a product description based on a trusted source feed. *** ## Properties A human-readable name for the component. {/* */} The Snowflake warehouse used to run the queries. The special value `[Environment Default]` uses the warehouse defined in the environment. Read [Overview of Warehouses](https://docs.snowflake.com/en/user-guide/warehouses-overview.html) to learn more. {/* */} The Snowflake database. The special value `[Environment Default]` uses the database defined in the environment. Read [Databases, Tables and Views - Overview](https://docs.snowflake.com/en/guides-overview-db) to learn more. {/* */} The Snowflake schema. The special value `[Environment Default]` uses the schema defined in the environment. Read [Database, Schema, and Share DDL](https://docs.snowflake.com/en/sql-reference/ddl-database.html) to learn more. {/* */} The table you want to update. {/* */} The alias for the target table. An alias allows a table to be referred to and is usually a name that is typically shorter and simpler than its actual name. {/* */} The alias for the source table. An alias allows a table to be referred to and is usually a name that is typically shorter and simpler than its actual name. {/* */} The condition used to match rows in the source data to rows in the target table, determining which rows to update. This is equivalent to the `ON` clause in a SQL `MERGE INTO` statement. Each expression is evaluated as true or false—rows where the condition is true are considered a match. Reference columns using the aliases set in **Source Alias** and **Target Alias**. Keys must uniquely identify rows and must not be NULL, otherwise you'll get unexpected results. Examples: * Simple key match: `"input"."customer_id" = "target"."customer_id"` * Date range match: `"input"."event_date" BETWEEN "target"."start_date" AND "target"."end_date"` {/* */} Select a case as previously defined in the Join Expression property. Add as many rows to the editor as you need, one per case. Choose an operation for when the corresponding case occurs according to the join expression. * **Delete:** Completely remove the row from the output table if the case is matched. * **Update:** Output the data as expected if a match is found. {/* */} The input column name from the matched input flow. Add as many rows to the editor as you need, one per input column. Property only available when a matched case results in an update. The name of the output column that the corresponding matched input is written to. This can be the same name as the input column if desired. {/* */} If **Yes**, allow non-matched data to continue through to the output. The columns this data is written to are defined in the **Insert Mapping** property. {/* */} The input column name from the unmatched input flow. Add as many rows to the editor as you need, one per input column. Property only available when an unmatched case is included. The name of the output column that the corresponding unmatched input is written to. This can be the same name as the input column if desired. A human-readable name for the component. {/* */} Select a [Databricks Unity Catalog](https://docs.databricks.com/en/data-governance/unity-catalog/index.html). The special value `[Environment Default]` uses the catalog defined in the environment. Selecting a catalog will determine which databases are available in the next parameter. {/* */} The Databricks schema. The special value `[Environment Default]` uses the schema defined in the environment. Read [Create and manage schemas](https://docs.databricks.com/en/data-governance/unity-catalog/create-schemas.html) to learn more. {/* */} The table you want to update. {/* */} The alias for the target table. An alias allows a table to be referred to and is usually a name that is typically shorter and simpler than its actual name. {/* */} The alias for the source table. An alias allows a table to be referred to and is usually a name that is typically shorter and simpler than its actual name. {/* */} The condition used to match rows in the source data to rows in the target table, determining which rows to update. This is equivalent to the `ON` clause in a SQL `MERGE INTO` statement. Each expression is evaluated as true or false—rows where the condition is true are considered a match. Reference columns using the aliases set in **Source Alias** and **Target Alias**. Keys must uniquely identify rows and must not be NULL, otherwise you'll get unexpected results. Examples: * Simple key match: `"input"."customer_id" = "target"."customer_id"` * Date range match: `"input"."event_date" BETWEEN "target"."start_date" AND "target"."end_date"` {/* */} Select a case as previously defined in the Join Expression property. Add as many rows to the editor as you need, one per case. Choose an operation for when the corresponding case occurs according to the join expression. * **Delete:** Completely remove the row from the output table if the case is matched. * **Update:** Output the data as expected if a match is found. {/* */} The input column name from the matched input flow. Add as many rows to the editor as you need, one per input column. Property only available when a matched case results in an update. The name of the output column that the corresponding matched input is written to. This can be the same name as the input column if desired. {/* */} If **Yes**, allow non-matched data to continue through to the output. The columns this data is written to are defined in the **Insert Mapping** property. {/* */} The input column name from the unmatched input flow. Add as many rows to the editor as you need, one per input column. Property only available when an unmatched case is included. The name of the output column that the corresponding unmatched input is written to. This can be the same name as the input column if desired. A human-readable name for the component. {/* */} Select the table schema. The special value `[Environment Default]` uses the schema defined in the environment. For more information on using multiple schemas, read [Schemas](https://docs.aws.amazon.com/redshift/latest/dg/r_Schemas_and_tables.html). {/* */} The table you want to update. {/* */} * **Source Column:** The input column name from the matched input flow. Add as many rows to the editor as you need, one per input column. Property only available when a matched case results in an update. * **Target Column:** The name of the output column that the corresponding matched input is written to. This can be the same name as the input column if desired. {/* */} Select how the table will update. Choose from: * **Update/Insert:** A traditional update statement, and an insert of incoming rows that don't match the target table (matching on Unique Keys). This is sometimes referred to as an upsert. The update counts reported will differ between the two strategies, even for the same datasets. This is because the database reports the number of affected rows. The first strategy will count all the deletes, plus all the inserts, which may overlap. The second strategy will count the number of updates, plus the number of rows added that weren't already updated. * **Delete/Insert:** Removes overlapping rows (matching on Unique Keys) and then inserts all incoming rows. This is effectively an update, and is very fast. However, if you don't have incoming values for all target columns, replaced rows will be NULL for those missing columns. Deleting rows in this way ideally requires a vacuum afterwards to recover space. This component does not arrange that vacuum for you, but there is a vacuum tables component available in an orchestration pipeline. For more information on vacuuming tables, read [Vacuuming tables](https://docs.aws.amazon.com/redshift/latest/dg/t_Reclaiming_storage_space202.html). {/* */} Selected column(s) from the input table used as unique keys. {/* */} * **Yes:** If the source column type does not match the target table type, attempt to CAST the value to the required target type. * **No:** Do not cast types. Amazon Redshift may still attempt to coerce the types in this case. A human-readable name for the component. {/* */} The Google Cloud project that owns the BigQuery dataset. The special value `[Environment Default]` uses the Google Cloud project defined in the environment. For more information, read [Creating projects](https://docs.cloud.google.com/resource-manager/docs/creating-managing-projects). {/* */} The Google BigQuery dataset where the table will be created or updated. The special value `[Environment Default]` uses the dataset defined in the environment. {/* */} The table you want to update. {/* */} * **Source Column:** The input column name from the matched input flow. Add as many rows to the editor as you need, one per input column. Property only available when a matched case results in an update. * **Target Column:** The name of the output column that the corresponding matched input is written to. This can be the same name as the input column if desired. {/* */} Select how the table will update. Choose from: * **Merge:** Combines insert and update operations into a single statement, and performs the operations in isolation (performs the operations separately from other operations that may be going on). * **Delete/Insert:** Removes overlapping rows (matching on Unique Keys) and then inserts all incoming rows. This is effectively an update, and is very fast. However, if you don't have incoming values for all target columns, replaced rows will be NULL for those missing columns. * **Update/Insert:** A traditional update statement, and an insert of incoming rows that don't match the target table (matching on **Unique Keys**). This is sometimes referred to as an upsert. * **Rewrite and Append:** Rewrites all rows not requiring updates, and then appends all rows that are updated. For large tables or small relative numbers of rows to be changed, this may be resource heavy. The update counts reported will differ between the **Delete/Insert** and **Update/Insert** strategies, even for the same datasets. This is because the database reports the number of affected rows. The first strategy will count all the deletes, plus all the inserts, which may overlap. The second strategy will count the number of updates, plus the number of rows added that weren't already updated. The number of requests allowed by Google BigQuery is severely limited. Exceeding these limits will cause jobs to fail. For more information, read the BigQuery [Quotas and limits](https://docs.cloud.google.com/bigquery/quotas#data_manipulation_language_statements) documentation. {/* */} Select the columns from the input table used as unique keys. The associated target columns are found using the **Update Mapping**. {/* */} * **Yes:** If the source column type does not match the target table type, attempt to CAST the value to the required target type. * **No:** Do not cast types. Google BigQuery may still attempt to coerce the types in this case.