> ## 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.

# AVRO Load

export const filetype_0 = ".avro"

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 <div style={{
    background: 'var(--colors-background-light, #f9fafb)',
    border: '1px solid var(--colors-border-default, #e5e7eb)',
    borderRadius: '12px',
    padding: '20px 28px',
    marginBottom: '28px',
    boxShadow: '0 1px 4px rgba(0,0,0,0.10)'
  }}>
      <table style={{
    width: '100%',
    borderCollapse: 'collapse'
  }}>
        <tbody>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle',
    width: '180px'
  }}>Project Availability</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>
              <div style={{
    display: 'flex',
    flexWrap: 'wrap',
    gap: '8px'
  }}>
                {allWarehouses.map((w, i) => <span key={i} style={{
    background: w.supported ? '#dcfce7' : '#fee2e2',
    color: w.supported ? '#15803d' : '#b91c1c',
    border: `1px solid ${w.supported ? '#bbf7d0' : '#fca5a5'}`,
    borderRadius: '9999px',
    padding: '3px 12px',
    fontSize: '0.85rem',
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
                    {w.name} {w.supported ? '✅' : '❌'}
                  </span>)}
              </div>
            </td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Component Type</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>{componentType}</td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    paddingBottom: '14px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Connection Inputs</td>
            <td style={{
    paddingBottom: '14px',
    verticalAlign: 'middle'
  }}>{connectionInputs}</td>
          </tr>
          <tr>
            <td style={{
    fontWeight: '600',
    paddingRight: '32px',
    whiteSpace: 'nowrap',
    verticalAlign: 'middle'
  }}>Connection Outputs</td>
            <td style={{
    verticalAlign: 'middle'
  }}>{connectionOutputs}</td>
          </tr>
        </tbody>
      </table>
    </div>;
};

<ComponentMetadata warehouses={["Snowflake", "Databricks", "Google BigQuery"]} unsupportedWarehouses={["Amazon Redshift"]} componentType="Connector, Orchestration" connectionInputs="One" connectionOutputs="Unlimited" />

The AVRO Load orchestration component loads data into a table from one or more Avro files. The component automatically infers the schema from the structure of the selected file(s), creates the corresponding table, and then loads the data into the table.

## Use cases

AVRO Load suits data engineering tasks that bring streaming and serialized data from Kafka-ecosystem and event-driven architectures into your warehouse. For example, you can use this component to:

* Load Avro-encoded event files deposited to cloud storage by upstream data pipelines for batch analysis in your warehouse.
* Load data from backend microservices or distributed systems that serialize records in Avro and deposit them to cloud storage on a recurring basis.
* Load data from systems that use Confluent Schema Registry, where Avro is the standard serialization format.
* Load audit logs or application events produced by streaming infrastructure and stored in Avro format in a data lake.
* Migrate data from Hadoop-based pipelines that use Avro for data serialization into a cloud warehouse.

You can authorize this component using either of these two methods:

* **Cloud Provider Credentials**: By default, explicit [Cloud Provider Credentials](/docs/guides/cloud-credentials) are used to facilitate cross-account or cross-cloud data loads.
* **Agent Identity**: If cloud provider credentials are not specified, the component attempts to use the Matillion Agent's native service identity to access the source data.

***

## Properties

<ResponseField name="Name" type="string" required>
  A human-readable name for the component.
</ResponseField>

### Connect

<Tabs>
  <Tab title="Snowflake">
    <ResponseField name="Type" type="drop-down" required>
      * **Snowflake Managed:** Load your file from a Snowflake internal stage.
      * **S3:** Load your file from an S3 bucket.
      * **Google Cloud Storage:** Load your file from a Google Cloud Storage bucket.
      * **Azure Blob Storage:** Load your file from an Azure Blob Storage container.
    </ResponseField>

    {/* <!-- param-start:[source.stage] | warehouses: [snowflake] --> */}

    <ResponseField name="Stage" type="drop-down" required>
      Select a staging area for the data. The special value \[New Stage] will create a temporary stage to be used for loading the data when the corresponding parameter values are provided.

      The options in this drop-down menu depend on the values you select for the `Database` and `Schema` parameters. If you change these values, the list of available options updates automatically, and the previously selected option may become invalid.

      When \[New Stage] is selected, the component uses the [cloud credentials](/docs/guides/cloud-credentials) configured for your environment to access the required resources.
    </ResponseField>

    <Tabs>
      <Tab title="Snowflake Managed">
        {/* <!-- param-start:[source.stagedFilePath] | warehouses: [snowflake] --> */}

        <ResponseField name="Staged file path" type="string">
          A stage may include directories. The user has the option to browse and select files from a specific directory path, for example, `/Example/Path`.

          If this is left blank, and if the **Pattern** parameter is also empty, all files from the stage will be loaded.
        </ResponseField>

        {/* <!-- param-end:[source.stagedFilePath] --> */}
      </Tab>

      <Tab title="S3">
        {/* <!-- param-start:[source.s3ObjectPrefix] | warehouses: [snowflake] --> */}

        <ResponseField name="S3 object prefix" type="file explorer" required>
          To retrieve the intended files, use the file explorer to enter the container path where the S3 bucket is located, or select from the list of S3 buckets.

          This must have the format `s3://<bucket>/<path>`.
        </ResponseField>

        {/* <!-- param-end:[source.s3ObjectPrefix] --> */}

        {/* <!-- param-start:[source.encryption] | warehouses: [snowflake] --> */}

        <ResponseField name="Encryption" type="drop-down" required>
          Decide how the files are encrypted inside the S3 bucket. This property is available when using an existing Amazon S3 location for staging.

          * **Client Side Encryption:** Encrypt the data according to a client-side master key. For more information, read [Protecting data using client-side encryption](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryption.html).
          * **KMS Encryption:** Encrypt the data according to a key stored on KMS. For more information, read [Using server-side encryption with AWS KMS keys](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html).
          * **S3 Encryption:** Encrypt the data according to a key stored on an S3 bucket. For more information, read [Using server-side encryption with Amazon S3-managed encryption keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html).
          * **None:** No encryption.
        </ResponseField>

        {/* <!-- param-end:[source.encryption] --> */}

        {/* <!-- param-start:[source.kmsKeyId] | warehouses: [snowflake] --> */}

        <ResponseField name="KMS key ID" type="drop-down" required>
          The ID of the KMS encryption key you have chosen to use in the `Encryption` property.

          Only available when `Encryption` is set to **KMS Encryption**.
        </ResponseField>

        {/* <!-- param-end:[source.kmsKeyId] --> */}

        {/* <!-- param-start:[source.masterKey] | warehouses: [snowflake] --> */}

        <ResponseField name="Master key" type="drop-down" required>
          The [secret definition](/docs/guides/secrets-and-secret-definitions) denoting your master key for client-side encryption. Your password should be saved as a secret definition before using this component.

          Only available when `Encryption` is set to **Client Side Encryption**.
        </ResponseField>

        {/* <!-- param-end:[source.masterKey] --> */}
      </Tab>

      <Tab title="Google Cloud Storage">
        {/* <!-- param-start:[source.storageIntegration] | warehouses: [snowflake] --> */}

        <ResponseField name="Storage integration" type="drop-down" required>
          Select the storage integration. Storage integrations are required to permit Snowflake to read from and write to a cloud storage location. Integrations must be set up in advance and configured to support Google Cloud Storage. For more information, read [Create storage integration](https://docs.snowflake.com/en/sql-reference/sql/create-storage-integration).
        </ResponseField>

        {/* <!-- param-end:[source.storageIntegration] --> */}

        {/* <!-- param-start:[source.googleStorageURLLocation] | warehouses: [snowflake] --> */}

        <ResponseField name="Google Storage URL location" type="file explorer" required>
          To retrieve the intended files, use the file explorer to enter the container path where the Google Cloud Storage bucket is located, or select from the list of Google Cloud Storage buckets.

          This must have the format `gs://<bucket>/<path>`.
        </ResponseField>

        {/* <!-- param-end:[source.googleStorageURLLocation] --> */}
      </Tab>

      <Tab title="Azure Blob Storage">
        {/* <!-- param-start:[source.azureStorageLocation] | warehouses: [snowflake] --> */}

        <ResponseField name="Azure storage location" type="file explorer" required>
          To retrieve the intended files, use the file explorer to enter the container path where the Azure Storage account is located, or select from the list of storage accounts.

          This must have the format `azure://<STORAGEACCOUNT>/<path>`.
        </ResponseField>

        {/* <!-- param-end:[source.azureStorageLocation] --> */}
      </Tab>
    </Tabs>

    <ResponseField name="Pattern" type="string">
      A valid regular expression (regex) to match part of a file's path or name. Files that match the pattern will be included in the load.

      If this parameter is left empty, the component automatically uses the pattern `*`, which matches all files within the specified `Staged file path` or `Stage` parameters. The pattern applies to the entire file path, not just the directory defined in `Staged file path`.

      The subfolder containing the object to load must be included here.

      <Note>
        * Only AVRO files are supported.
        * Ensure that the pattern entered correctly targets the files you intend to load.
      </Note>
    </ResponseField>
  </Tab>

  <Tab title="Databricks">
    <ResponseField name="Type" type="drop-down" required>
      * **S3:** Load your file from an S3 bucket.
      * **Google Cloud Storage:** Load your file from a Google Cloud Storage bucket.
      * **Azure Blob Storage:** Load your file from an Azure Blob Storage container.
    </ResponseField>

    <Tabs>
      <Tab title="S3">
        {/* <!-- param-start:[source.s3ObjectPrefix] | warehouses: [databricks] --> */}

        <ResponseField name="S3 object prefix" type="file explorer" required>
          To retrieve the intended files, use the file explorer to enter the container path where the S3 bucket is located, or select from the list of S3 buckets.

          This must have the format `s3://<bucket>/<path>`.
        </ResponseField>

        {/* <!-- param-end:[source.s3ObjectPrefix] --> */}
      </Tab>

      <Tab title="Google Cloud Storage">
        {/* <!-- param-start:[source.googleStorageURLLocation] | warehouses: [databricks] --> */}

        <ResponseField name="Google Storage URL location" type="file explorer" required>
          To retrieve the intended files, use the file explorer to enter the container path where the Google Cloud Storage bucket is located, or select from the list of Google Cloud Storage buckets.

          This must have the format `gs://<bucket>/<path>`.

          For this to work, an external location with access to the specified location must be configured. For more information, read [External Locations | Databricks on AWS](https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-external-locations).
        </ResponseField>

        {/* <!-- param-end:[source.googleStorageURLLocation] --> */}
      </Tab>

      <Tab title="Azure Blob Storage">
        {/* <!-- param-start:[source.azureStorageLocation] | warehouses: [databricks] --> */}

        <ResponseField name="Azure storage location" type="file explorer" required>
          To retrieve the intended files, use the file explorer to enter the container path where the Azure Storage account is located, or select from the list of storage accounts.

          This must have the format `azure://<STORAGEACCOUNT>/<path>`.
        </ResponseField>

        {/* <!-- param-end:[source.azureStorageLocation] --> */}
      </Tab>
    </Tabs>

    <ResponseField name="Glob pattern" type="string">
      A valid glob pattern to match part of a file's path or name. Files that match the pattern will be included in the load.

      If this parameter is left empty, the component automatically uses the pattern `*`, which matches all files within the specified location parameters. The pattern applies to the entire file path, not just the directory defined in the location parameter.

      <Note>
        * Only `AVRO` files are supported.
        * Ensure that the pattern entered correctly targets the files you intend to load.
      </Note>
    </ResponseField>
  </Tab>

  <Tab title="Google BigQuery">
    <ResponseField name="Type" type="drop-down" required>
      Select **Google Cloud Storage** to load your file from a Google Cloud Storage bucket.
    </ResponseField>

    <ResponseField name="Google Storage URL location" type="file explorer" required>
      To retrieve the intended files, use the file explorer to enter the container path where the Google Cloud Storage bucket is located, or select from the list of Google Cloud Storage buckets.

      This must have the format `gs://<bucket>/<path>`.
    </ResponseField>

    <ResponseField name="File filter" type="string">
      Filter for specific files by their file name, including their file extension. You can use wildcards in the file name, for example `prefix_*{filetype}`.

      If this field is left empty, all {filetype_0} files at the specified Google Storage URL location are loaded.

      If the specified Google Storage URL location contains a `*`, you can't apply a file filter.
    </ResponseField>
  </Tab>
</Tabs>

### Configure

<Tabs>
  <Tab title="Snowflake">
    <ResponseField name="File format" type="drop-down" required>
      The default value is set to `[New File Format]`. Specify a file format, and a temporary format with those settings will be used when the component runs. Alternatively, select a pre-made file format.
    </ResponseField>

    {/* <!-- param-start:[avroFormat.compression] | warehouses: [snowflake] --> */}

    <ResponseField name="Compression" type="drop-down" required>
      Select the compression algorithm used on the file being loaded.

      The default setting is AUTO.
    </ResponseField>

    {/* <!-- param-start:[avroFormat.trimSpace] | warehouses: [snowflake] --> */}

    <ResponseField name="Trim space" type="boolean" required>
      When True, removes whitespace from fields. Default setting is False.

      This will only work when `Match By Column Name` is set to either **Case Insensitive** or **Case Sensitive** in the **Advanced Settings** below.
    </ResponseField>

    {/* <!-- param-start:[avroFormat.replaceInvalidCharacters] | warehouses: [snowflake] --> */}

    <ResponseField name="Replace invalid characters" type="boolean" required>
      Snowflake replaces invalid UTF-8 characters with the Unicode replacement character. When False (default), the load operation produces an error when invalid UTF-8 character encoding is detected.

      The default setting is False.
    </ResponseField>
  </Tab>

  <Tab title="Databricks">
    <ResponseField name="Ignore corrupt files" type="boolean">
      When set to Yes, corrupt input files are skipped and not included in the load.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.ignoreMissingFiles] | warehouses: [databricks] --> */}

    <ResponseField name="Ignore missing files" type="boolean">
      When set to Yes, files that cannot be found are ignored during the load process.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.modifiedAfter] | warehouses: [databricks] --> */}

    <ResponseField name="Modified after" type="string">
      An optional timestamp as a filter to only ingest files that have a modification timestamp **after** the provided timestamp.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.modifiedBefore] | warehouses: [databricks] --> */}

    <ResponseField name="Modified before" type="string">
      An optional timestamp as a filter to only ingest files that have a modification timestamp **before** the provided timestamp.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.recursiveFileLookup] | warehouses: [databricks] --> */}

    <ResponseField name="Recursive file lookup" type="boolean">
      When set to **Yes**, files are read recursively from all subdirectories under the specified path. When enabled, partition inference is disabled. To control which files are loaded, use the **Glob pattern** property instead.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.avroSchema] | warehouses: [databricks] --> */}

    <ResponseField name="AVRO schema" type="string">
      An AVRO schema in JSON format to use when loading the data. If not provided, Databricks automatically infers the schema from the data.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.datetimeRebaseMode] | warehouses: [databricks] --> */}

    <ResponseField name="Datetime rebase mode" type="drop-down">
      This property controls how Databricks handles datetime values that are out of the supported range of `TIMESTAMP_NTZ` when loading AVRO files. The default value is **CORRECTED**.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.mergeSchema] | warehouses: [databricks] --> */}

    <ResponseField name="Merge schema" type="boolean">
      When set to Yes, schemas from all input files are merged during the load.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.readerCaseSensitive] | warehouses: [databricks] --> */}

    <ResponseField name="Reader case sensitive" type="boolean">
      If **Yes**, column names will be case-sensitive during parsing.
    </ResponseField>

    {/* <!-- param-start:[avroOptions.rescuedDataColumn] | warehouses: [databricks] --> */}

    <ResponseField name="Rescued data column" type="string">
      A column name to store unparseable data when loading AVRO files. If not provided, unparseable data will be ignored.
    </ResponseField>
  </Tab>

  <Tab title="Google BigQuery">
    <ResponseField name="Enable logical types" type="boolean">
      When set to **Yes**, Avro logical types are converted to their corresponding Google BigQuery data types, for example TIMESTAMP, DATE, TIME, and NUMERIC.

      When set to **No**, Google BigQuery uses the underlying primitive type instead. Default is **No**.
    </ResponseField>

    <ResponseField name="Decimal target types" type="dual listbox">
      Select the data types that Google BigQuery can use to represent decimal values from the source file. Google BigQuery uses the smallest selected type that can represent each value.

      * **NUMERIC:** Supports up to 29 digits of precision and 9 digits of scale.
      * **BIGNUMERIC:** Supports up to 76 digits of precision and 38 digits of scale.
      * **STRING:** Preserves the original precision by representing the value as a string.
    </ResponseField>
  </Tab>
</Tabs>

### Destination

<Tabs>
  <Tab title="Snowflake">
    <ResponseField name="Warehouse" type="drop-down" required>
      <SnowflakeWarehouseQuery />
    </ResponseField>

    {/* <!-- param-start:[database] | warehouses: [snowflake] --> */}

    <ResponseField name="Database" type="drop-down" required>
      <SnowflakeDatabase />
    </ResponseField>

    {/* <!-- param-start:[schema] | warehouses: [snowflake] --> */}

    <ResponseField name="Schema" type="drop-down" required>
      <SnowflakeSchema />
    </ResponseField>

    {/* <!-- param-start:[targetTableName] | warehouses: [snowflake] --> */}

    <ResponseField name="Target table name" type="string" required>
      Specify the name of the newly created or existing table to load data into. The table will be created according to the `Load strategy` you select below.
    </ResponseField>

    {/* <!-- param-start:[loadStrategy] | warehouses: [snowflake] --> */}

    <ResponseField name="Load strategy" type="drop-down" required>
      * **Replace:** If the specified table name already exists, that table will be destroyed and replaced by the table created during this pipeline run.
      * **Truncate and Insert:** Each time the pipeline runs, two operations are performed: first, the table is truncated, meaning all existing rows are deleted. Then, your new rows are inserted. The table itself is never destroyed and recreated.
      * **Fail if Exists:** If the specified table name already exists, this pipeline will fail to run, and no data will be copied to the table.
      * **Append:** If the specified table name already exists, then the data is inserted without altering or deleting the existing data in the table. It's appended onto the end of the existing data in the table. If the specified table name doesn't exist, then an error message will appear and the table is not created. You must **always** provide a table name.
    </ResponseField>
  </Tab>

  <Tab title="Databricks">
    <ResponseField name="Catalog" type="drop-down" required>
      <DatabricksCatalog />
    </ResponseField>

    {/* <!-- param-start:[schema] | warehouses: [databricks] --> */}

    <ResponseField name="Schema (database)" type="drop-down" required>
      <DatabricksSchema />
    </ResponseField>

    {/* <!-- param-start:[targetTableName] | warehouses: [databricks] --> */}

    <ResponseField name="Target table name" type="string" required>
      The name of the table to be created. The table will be created according to the `Load strategy` you select below.
    </ResponseField>

    {/* <!-- param-start:[loadStrategy] | warehouses: [databricks] --> */}

    <ResponseField name="Load strategy" type="drop-down" required>
      * **Replace:** If the specified table name already exists, that table will be destroyed and replaced by the table created during this pipeline run.
      * **Truncate and Insert:** Each time the pipeline runs, two operations are performed: first, the table is truncated, meaning all existing rows are deleted. Then, your new rows are inserted. The table itself is never destroyed and recreated.
      * **Fail if Exists:** If the specified table name already exists, this pipeline will fail to run, and no data will be copied to the table.
      * **Append:** If the specified table name already exists, then the data is inserted without altering or deleting the existing data in the table. It's appended onto the end of the existing data in the table. If the specified table name doesn't exist, then an error message will appear and the table is not created. You must **always** provide a table name.

      If not specified, the default is **Fail if Exists**.

      <Note>
        Databricks uses `COPY INTO`, which is idempotent. This means it tracks which source files have already been loaded into the target Delta table and skips them on subsequent runs.

        Enabling **Force load** overrides this behavior for the **Truncate and Insert** and **Append** load strategies, causing all matching source files to be reprocessed.
      </Note>
    </ResponseField>
  </Tab>

  <Tab title="Google BigQuery">
    <ResponseField name="Project" type="drop-down" required>
      Select the ID of the Google Cloud Platform project to load data into. The special value `[Environment Default]` uses the project defined in the environment.
    </ResponseField>

    <ResponseField name="Dataset" type="drop-down" required>
      Select the Google BigQuery dataset to load data into. The special value `[Environment Default]` uses the dataset defined in the environment.
    </ResponseField>

    <ResponseField name="Target table name" type="string" required>
      The name of the table to be created in your Google BigQuery project. You can use a [Table Input](/docs/components/table-input) component in a transformation pipeline to access and transform this data after it has been loaded.
    </ResponseField>

    <ResponseField name="Load strategy" type="drop-down" required>
      Define what happens if the table name already exists in the specified destination.

      * **Replace:** If the specified table name already exists, that table will be destroyed and replaced by the table created during this pipeline run.
      * **Truncate and Insert:** Each time the pipeline runs, two operations are performed: first, the table is truncated, meaning all existing rows are deleted. Then, your new rows are inserted. The table itself is never destroyed and recreated.
      * **Fail if Exists:** If the specified table name already exists, this pipeline will fail to run.
      * **Append:** If the specified table name already exists, then the data is inserted without altering or deleting the existing data in the table. It's appended onto the end of the existing data in the table. If the specified table name doesn't exist, then the table will be created, and your data will be inserted into the table.
    </ResponseField>
  </Tab>
</Tabs>

### Advanced Settings

<Tabs>
  <Tab title="Snowflake">
    <OnError />

    <ResponseField name="N" type="integer" required>
      Specify the number of errors or the percentage of errors required to skip the file. This parameter only accepts integer characters. `%` is not accepted. Specify percentages as a number only.

      This parameter is only available when `On Error` is set to either **Skip File When n Errors** or **Skip File When n% Errors**.
    </ResponseField>

    {/* <!-- param-start:[advancedCopyOptions.sizeLimit] | warehouses: [snowflake] --> */}

    <ResponseField name="Size limit (in bytes)" type="integer">
      Specify the maximum size, in bytes, of data to be loaded for a given COPY statement. If the maximum is exceeded, the COPY operation discontinues loading files. For more information, refer to the Snowflake documentation.
    </ResponseField>

    {/* <!-- param-start:[advancedCopyOptions.purgeFiles] | warehouses: [snowflake] --> */}

    <ResponseField name="Purge files" type="boolean" required>
      When True, purges data files after the data is successfully loaded. Default setting is False.
    </ResponseField>

    {/* <!-- param-start:[advancedCopyOptions.matchByColumnName] | warehouses: [snowflake] --> */}

    <ResponseField name="Match by column name" type="drop-down" required>
      Specify whether to load semi-structured data into columns in the target table that match corresponding columns represented in the data.

      * **Case Insensitive:** Load semi-structured data into columns in the target table that match corresponding columns represented in the data. Column names should be case-insensitive.
      * **Case Sensitive:** Load semi-structured data into columns in the target table that match corresponding columns represented in the data. Column names should be case-sensitive.
      * **None:** The COPY operation loads the semi-structured data into a variant column or, if a query is included in the COPY statement, transforms the data.
    </ResponseField>

    {/* <!-- param-start:[advancedCopyOptions.truncateColumns] | warehouses: [snowflake] --> */}

    <ResponseField name="Truncate columns" type="boolean" required>
      When True, strings are automatically truncated to the target column length. When False (default), the COPY statement produces an error if a loaded string exceeds the target column length.
    </ResponseField>

    {/* <!-- param-start:[advancedCopyOptions.forceLoad] | warehouses: [snowflake] --> */}

    <ResponseField name="Force load" type="boolean" required>
      When True, loads all files, regardless of whether they have been loaded previously and haven't changed since they were loaded. Default setting is False.

      When set to True, this option reloads files and can lead to duplicated data in a table.
    </ResponseField>
  </Tab>

  <Tab title="Databricks">
    <ResponseField name="Force load" type="boolean" required>
      When True, loads all files, regardless of whether they have been loaded previously and haven't changed since they were loaded. Default setting is False.

      When set to True, this option reloads files and can lead to duplicated data in a table. The `Load strategy` in the destination needs to be **Truncate and Insert** or **Append** for this to work.
    </ResponseField>
  </Tab>

  <Tab title="Google BigQuery">
    <ResponseField name="Default rounding mode" type="drop-down">
      Select the rounding mode to use when storing numeric data types. For more information, read the Google BigQuery [RoundingMode](https://docs.cloud.google.com/bigquery/docs/schemas#rounding_mode) documentation.

      * `ROUND_HALF_AWAY_FROM_ZERO` rounds half values away from zero.
      * `ROUND_HALF_EVEN` rounds half values to the nearest even value.
    </ResponseField>
  </Tab>
</Tabs>