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

# JSON Load

export const filetype_0 = ".json"

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, Test" connectionInputs="One" connectionOutputs="Unlimited" />

The JSON Load orchestration component loads data into a table from one or more JSON 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.

<Note>
  For Google BigQuery projects, the JSON Load connector only supports newline-delimited JSON files (also called NDJSON or JSON Lines) with one complete JSON object per line.
</Note>

## Use cases

JSON Load suits data engineering and analytics tasks that bring semi-structured or API-originated data into your warehouse. For example, you can use this component to:

* Load API response exports or webhook payloads stored as JSON files for analysis alongside structured warehouse data.
* Ingest document exports from NoSQL databases such as MongoDB or DynamoDB to enable relational querying.
* Load application event logs or audit trails stored in JSON for compliance reporting or operational analytics.
* Bring in IoT device telemetry or mobile app event data stored as JSON files as a first step before downstream transformation.
* Ingest configuration or metadata files produced by application deployments to track changes over time.

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 JSON 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 JSON 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:[jsonFormat.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:[jsonFormat.enableOctal] | warehouses: [snowflake] --> */}

    <ResponseField name="Enable octal" type="boolean" required>
      When True, enables the parsing of octal values.

      Default setting is False.
    </ResponseField>

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

    <ResponseField name="Allow duplicates" type="boolean" required>
      When True, allows duplicate object field names.

      Default setting is False.
    </ResponseField>

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

    <ResponseField name="Strip outer array" type="boolean" required>
      When True, instructs the JSON parser to remove outer brackets.

      Default setting is False.
    </ResponseField>

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

    <ResponseField name="Strip null values" type="boolean" required>
      When True, instructs the JSON parser to remove any object fields or array elements containing NULL values.

      Default setting is False.
    </ResponseField>

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

    <ResponseField name="Ignore UTF8 errors" type="boolean" required>
      When True, replaces any invalid UTF-8 sequences with Unicode characters. When False, UTF-8 errors will not produce an error in the pipeline run.

      Default setting is False.
    </ResponseField>

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

    <ResponseField name="Binary format" type="drop-down" required>
      Determines how binary string values are encoded in data files. Use this setting when importing data into a table's binary columns.

      Choose from the following options:

      * **HEX:** Binary string values are encoded as hexadecimal strings.
      * **BASE64:** Binary string values are encoded as Base64 strings.
      * **UTF8:** Binary string values are encoded as UTF-8 strings.

      Default setting is HEX.

      This will only work when `Match by column name` is set to either **Case Insensitive** or **Case Sensitive**.
    </ResponseField>

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

    <ResponseField name="Multi line" type="boolean" required>
      Allows multiple lines in a JSON record. When set to **No**, any JSON record containing a newline character is considered invalid, and will trigger an error.

      Default setting is False.
    </ResponseField>

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

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

      Default setting is False.
    </ResponseField>

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

    <ResponseField name="Skip byte order mark" type="boolean" required>
      Determines whether to ignore a BOM (byte order mark) in the input file.

      If set to FALSE, Snowflake processes any BOM found in the file, which may lead to errors or cause the BOM to be included in the first column of the table.

      Default setting is True.
    </ResponseField>

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

    <ResponseField name="Null if" type="editor">
      Specify one or more strings (one string per row of the table) to convert to NULL values. When one of these strings is encountered in the file, it is replaced with an SQL NULL value for that field in the loaded table. Click + to add a string.

      This will only work when `Match By Column Name` is set to either **Case Insensitive** or **Case Sensitive**.
    </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:[jsonOptions.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:[jsonOptions.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:[jsonOptions.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:[jsonOptions.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:[jsonOptions.allowBackslashEscapingAnyCharacter] | warehouses: [databricks] --> */}

    <ResponseField name="Allows backslash escaping any character" type="boolean">
      If **Yes**, will allow the quoting of all characters using the backslash quoting mechanism in JSON records.
    </ResponseField>

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

    <ResponseField name="Allow comments" type="boolean">
      If **Yes**, will allow JAVA/C++ style comments in JSON records.
    </ResponseField>

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

    <ResponseField name="Allow non-numeric numbers" type="boolean">
      If **Yes**, will allow using non-numeric number strings such as `NaN`, `Infinity`, `-Infinity` in JSON records.
    </ResponseField>

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

    <ResponseField name="Allow numeric leading zeros" type="boolean">
      If **Yes**, will allow leading zeros in numbers in JSON records.
    </ResponseField>

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

    <ResponseField name="Allow single quotes" type="boolean">
      If **Yes**, will allow single quotes in addition to double quotes in JSON records.
    </ResponseField>

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

    <ResponseField name="Allow unquoted control chars" type="boolean">
      If **Yes**, will allow JSON strings to include unquoted control characters (ASCII characters with values less than 32, including tab and line feed characters) in JSON records.
    </ResponseField>

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

    <ResponseField name="Allow unquoted field names" type="boolean">
      If **Yes**, will allow unquoted JSON field names (which are allowed by JavaScript, but not by the JSON specification).
    </ResponseField>

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

    <ResponseField name="Bad records path" type="string">
      An optional path to store bad records encountered during parsing. When specified, records that cannot be parsed are written to this location instead of causing the load to fail.
    </ResponseField>

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

    <ResponseField name="Column name of corrupt record" type="string">
      An optional column name to store the malformed JSON string when a record cannot be parsed. This allows you to capture and analyze corrupt records in the target table.
    </ResponseField>

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

    <ResponseField name="Date format" type="string">
      Describe the format of date values in the data files to be loaded. For example, `yyyy-MM-dd`.
    </ResponseField>

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

    <ResponseField name="Drop field if all null" type="boolean">
      If **Yes**, will ignore columns that contain only null values when inferring the schema.
    </ResponseField>

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

    <ResponseField name="Encoding" type="string">
      Select the character encoding to use when reading the input files.
    </ResponseField>

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

    <ResponseField name="Infer timestamp" type="boolean">
      If **Yes**, will attempt to infer timestamp strings as a `TimestampType` during schema inference.
    </ResponseField>

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

    <ResponseField name="Line separator" type="string">
      Specify the character or sequence of characters used to separate individual records (rows) in the JSON file.
    </ResponseField>

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

    <ResponseField name="Locale" type="string">
      Sets the locale for date and timestamp parsing. The locale should be in BCP 47 language tag format (e.g., `en-US`).
    </ResponseField>

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

    <ResponseField name="Mode" type="drop-down">
      Controls how the parser handles corrupt or malformed records. Options include:

      * **PERMISSIVE:** Sets fields to null when encountering corrupted records and places the malformed string into a field configured by **Column name of corrupt record**. This is the default setting.
      * **DROPMALFORMED:** Ignores and drops rows containing corrupted records.
      * **FAILFAST:** Throws an exception when encountering corrupted records.
    </ResponseField>

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

    <ResponseField name="Multi line" type="boolean">
      If **Yes**, will parse records which may span multiple lines.
    </ResponseField>

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

    <ResponseField name="Primitives as string" type="boolean">
      If **Yes**, primitive data types are interpreted as strings in JSON files. If not specified, the default is **No**.
    </ResponseField>

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

    <ResponseField name="Prefers decimal" type="boolean">
      If **Yes**, all floating-point values will be treated as a decimal type during schema inference.
    </ResponseField>

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

    <ResponseField name="Reader case sensitive" type="boolean">
      Specifies case sensitivity behavior during schema rescue. If **Yes**, data columns are matched to the schema by name in a case-sensitive manner.
    </ResponseField>

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

    <ResponseField name="Rescued data column" type="string">
      An optional column name to store data that does not match the schema. When specified, fields that don't match the expected schema are collected into this column as a JSON string.
    </ResponseField>

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

    <ResponseField name="Single variant column" type="string">
      An optional column name to store the entire JSON record as a single `VARIANT` type value, rather than parsing it into separate columns.
    </ResponseField>

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

    <ResponseField name="Timestamp format" type="string">
      Describe the format of timestamp values in the data files to be loaded.
    </ResponseField>

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

    <ResponseField name="Time zone" type="string">
      Sets the timezone to use when parsing timestamps.
    </ResponseField>
  </Tab>

  <Tab title="Google BigQuery">
    <ResponseField name="Date format" type="string">
      Define how date values are formatted in your files, for example `MM/DD/YYYY`.

      If you leave this blank, the default format `YY-MM-DD` is used.
    </ResponseField>

    <ResponseField name="Datetime format" type="string">
      Define how date values are formatted in your files, for example `MM/DD/YYYY HH24:MI:SS.FF3`.

      If you leave this blank, the default format `YYYY-MM-DD HH:MM:SS[.SSSSSS]` is used.
    </ResponseField>

    <ResponseField name="Time format" type="string">
      Define how time values are formatted in your files, for example `HH24:MI:SS.FF3`.

      If you leave this blank, the default format `HH:MM:SS[.SSSSSS]` is used.
    </ResponseField>

    <ResponseField name="Timestamp format" type="string">
      Define how timestamp values are formatted in your files, for example `MM/DD/YYYY HH24:MI:SS.FF3`.

      If you leave this blank, Google BigQuery attempts to parse timestamp values automatically.
    </ResponseField>

    <ResponseField name="Time zone" type="string">
      The default time zone to apply when parsing timestamp values that do not include a specific time zone. For example, `America/New_York` or `UTC+05:30`.

      If you leave this blank, UTC is used.
    </ResponseField>

    <ResponseField name="Gzip data" type="boolean">
      When set to **Yes**, Google BigQuery treats the source files as gzip-compressed.

      Note that compressed files cannot be read in parallel, which may impact load performance. Default is **No**.
    </ResponseField>

    <ResponseField name="Max bad records" type="string">
      The maximum number of bad records to ignore before returning an error. A record is considered bad if it cannot be parsed. For example, enter `10` to allow up to 10 unparseable rows before the load fails.

      If you leave this blank, the load will fail if there are any bad records.
    </ResponseField>

    <ResponseField name="Ignore unknown values" type="boolean">
      When set to **Yes**, extra fields in the file that are not present in the table schema are silently ignored.

      When set to **No**, extra fields cause the load to fail.
    </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>